Crea un'app di base per lanciare i dadi interattivi

In questo codelab, creerai un'app per Android Dice Roller in cui gli utenti possono fare clic su un Button nell'app per tirare un dado. Il risultato del tiro verrà mostrato in un TextView sullo schermo.

Utilizzerai Layout Editor in Android Studio per creare il layout dell'app, quindi scriverai il codice Kotlin per ciò che accade quando viene fatto clic su Button.

Prerequisiti

• Come creare ed eseguire un'app "Hello, World!" in Android Studio.
• Avere familiarità con l'utilizzo di TextViews e ImageViews in un'app.
• Come modificare gli attributi di un TextView nell'editor layout.
• Come estrarre il testo in una risorsa stringa per semplificare la traduzione dell'app e il riutilizzo delle stringhe.
• Le basi della programmazione Kotlin insegnate nei codelab precedenti.

Obiettivi didattici

• Come aggiungere un Button a un'app per Android.
• Come aggiungere un comportamento quando viene toccato un Button nell'app.
• Come aprire e modificare il codice Activity di un'app.
• Come visualizzare un messaggio Toast.
• Come aggiornare i contenuti di un TextView mentre l'app è in esecuzione.

Cosa creerai

• Un'app per Android Dice Roller con un Button per lanciare un dado e aggiorna il testo sullo schermo con il risultato del lancio.

Cosa serve

• Un computer su cui è installato Android Studio.

Ecco l'aspetto dell'app al termine di questo codelab.

Creare un progetto di attività vuoto

1. Se hai già un progetto aperto in Android Studio, vai a File > New > New Project… per aprire la schermata Create New Project (Crea nuovo progetto).
2. In Crea nuovo progetto, crea un nuovo progetto Kotlin utilizzando il modello Attività vuota.
3. Chiama l'app "Dice Roller" (Tiro di dadi) con un livello API minimo di 19 (KitKat).

Importante:se non hai familiarità con la creazione di un nuovo progetto in Android Studio, consulta l'articolo Crea ed esegui la tua prima app per Android per maggiori dettagli.

4. Esegui la nuova app, che dovrebbe avere questo aspetto.
   

Apri l'editor del layout

1. Nella finestra Progetto, fai doppio clic su activity_main.xml (app > res > layout > activity_main.xml) per aprirlo. Dovresti visualizzare l'editor layout, con solo il TextView "Hello World" al centro dell'app.
   

Successivamente, aggiungerai un Button alla tua app. Un Button è un elemento dell'interfaccia utente (UI) in Android che l'utente può toccare per eseguire un'azione.

In questa attività, aggiungi un Button sotto il TextView "Hello World". TextView e Button si troveranno all'interno di un ConstraintLayout, che è un tipo di ViewGroup.

Quando ci sono Views all'interno di un ViewGroup, i Views sono considerati figli del genitoreViewGroup. Nel caso della tua app, TextView e Button sarebbero considerati figli del genitore ConstraintLayout.

Procedi con l'aggiunta di un Button come figlio del ConstraintLayout esistente nella tua app.

Nota:come in un albero genealogico, in una gerarchia di visualizzazione, le visualizzazioni principali possono essere a loro volta visualizzazioni secondarie e le visualizzazioni secondarie possono essere principali per altre visualizzazioni secondarie.

Aggiungere un pulsante al layout

1. Trascina un Button dalla tavolozza nella visualizzazione Struttura, posizionandolo sotto il TextView "Hello World".
   
2. Sotto la tavolozza nella struttura dei componenti, verifica che Button e TextView siano elencati in ConstraintLayout (come elementi secondari di ConstraintLayout).
3. Viene visualizzato un errore che indica che Button non è vincolato. Poiché Button si trova all'interno di ConstraintLayout, devi impostare i vincoli verticali e orizzontali per posizionarlo.

Posizionare il pulsante

In questo passaggio aggiungerai un vincolo verticale dalla parte superiore di Button alla parte inferiore di TextView. In questo modo, Button verrà posizionato sotto TextView.

1. Nella visualizzazione Progettazione, tieni premuto il cerchio bianco con un bordo blu sul bordo superiore di Button. Trascina il puntatore e una freccia lo seguirà. Rilascia quando raggiungi il bordo inferiore di "Hello World" TextView. In questo modo viene stabilito un vincolo di layout e Button scorre verso l'alto fino a posizionarsi appena sotto TextView.
   
2. Guarda gli attributi sul lato destro dell'editor di layout.
3. Nel widget Constraint,nota un nuovo vincolo di layout impostato sulla parte inferiore di TextView, Top → BottomOf textView (0 dp). (0 dp) significa che il margine è pari a 0. Hai anche un errore per i vincoli orizzontali mancanti.
   
4. Aggiungi un vincolo orizzontale dal lato sinistro di Button al lato sinistro dell'elemento principale ConstraintLayout.
5. Ripeti l'operazione sul lato destro, collegando il bordo destro di Button al bordo destro di ConstraintLayout. Il risultato dovrebbe essere simile a questo:

6. Con Button ancora selezionato, il widget Vincolo dovrebbe essere simile al seguente. Nota i due vincoli aggiuntivi che sono stati aggiunti: Inizio → Inizio elemento padre (0 dp) e Fine → Fine elemento padre (0 dp). Ciò significa che Button è centrato orizzontalmente nel relativo elemento principale, ConstraintLayout.
   

7. Esegui l'app. Dovrebbe avere un aspetto simile a quello dello screenshot riportato di seguito. Puoi fare clic su Button, ma non succede ancora nulla. Continuiamo così.

Modificare il testo del pulsante

Apporterai altre modifiche alla UI nell'editor layout.

Anziché visualizzare l'etichetta Button "Pulsante", modificala in modo che indichi la funzione del pulsante: "Tira".

1. Nell'editor layout, con Button selezionato, vai ad Attributi, modifica il testo in Roll e premi il tasto Enter (Return su Mac).

2. Nell'albero dei componenti, accanto a Button viene visualizzato un triangolo di avviso arancione. Se passi il cursore sopra il triangolo, viene visualizzato un messaggio. Android Studio ha rilevato una stringa hardcoded ("Roll") nel codice dell'app e suggerisce di utilizzare una risorsa stringa.

Se una stringa è codificata in modo permanente, l'app sarà più difficile da tradurre in altre lingue e sarà più difficile riutilizzare le stringhe in diverse parti dell'app. Fortunatamente, Android Studio ha una correzione automatica per te.

3. Nell'albero dei componenti , fai clic sul triangolo arancione.

Viene visualizzato il messaggio di avviso completo.

4. Nella parte inferiore del messaggio, in Correzione suggerita, fai clic sul pulsante Correggi. Potrebbe essere necessario scorrere verso il basso.
5. Viene visualizzata la finestra di dialogo Estrai risorsa. Estrarre una stringa significa prendere il testo "Roll" e creare una risorsa stringa chiamata roll in strings.xml (app > res > values > strings.xml). I valori predefiniti sono corretti, quindi fai clic su Ok.

6. Nota che in Attributi, l'attributo text per Button ora indica @string/roll, facendo riferimento alla risorsa appena creata.
   

Nella visualizzazione Progettazione, il Button dovrebbe ancora indicare Rotolo.

Applica uno stile a TextView

Il testo "Hello World!" è piuttosto piccolo e il messaggio non è pertinente per la tua app. In questo passaggio sostituirai il piccolo messaggio "Hello, World!" con un numero per mostrare il valore tirato e ingrandirai il carattere in modo che sia più facile da vedere.

1. Nell'editor di progettazione, seleziona TextView in modo che i relativi attributi vengano visualizzati nella finestra Attributi.
2. Modifica textSize di TextView impostandolo su 36sp, in modo che sia grande e facile da leggere. Potresti dover scorrere per trovare textSize.

3. Cancella l'attributo text [testo] di TextView. Non devi mostrare nulla in TextView finché l'utente non tira i dadi.

Tuttavia, è molto utile visualizzare del testo in TextView quando modifichi il layout e il codice della tua app. A questo scopo, puoi aggiungere del testo a TextView che è visibile solo per l'anteprima del layout, ma non quando l'app è in esecuzione

.

4. Seleziona TextView nell'albero dei componenti.
5. In Attributi comuni, trova l'attributo testo e, sotto, un altro attributo testo con un'icona a forma di strumento. L'attributo text è ciò che verrà visualizzato dall'utente quando l'app è in esecuzione. L'attributo testo con un'icona a forma di strumento è l'attributo "testo degli strumenti", riservato agli sviluppatori.
6. Imposta il testo degli strumenti su "1" in TextView (per simulare un tiro di dado di 1). "1" verrà visualizzato solo nell'editor di progettazione in Android Studio, ma non quando esegui l'app su un dispositivo o un emulatore reale.

Tieni presente che, poiché questo testo viene visualizzato solo dagli sviluppatori di app, non è necessario creare una risorsa stringa.

7. Guarda la tua app nell'anteprima. Viene visualizzato "1".

8. Esegui l'app. Ecco l'aspetto dell'app quando viene eseguita su un emulatore. Il numero "1" non viene visualizzato. Questo è il comportamento corretto.

Ottimo, hai finito di apportare modifiche al layout.

Hai un'app con un pulsante, ma se lo tocchi non succede nulla. Per modificare questo comportamento, dovrai scrivere del codice Kotlin che tiri i dadi e aggiorni lo schermo quando viene toccato il pulsante.

Per apportare questa modifica, devi capire un po' di più la struttura di un'app per Android.

Un Activity fornisce la finestra in cui la tua app disegna la sua UI. In genere, un'Activity occupa l'intero schermo dell'app in esecuzione. Ogni app ha una o più attività. L'attività di primo livello o la prima attività viene spesso chiamata MainActivity ed è fornita dal modello di progetto. Ad esempio, quando l'utente scorre l'elenco delle app sul dispositivo e tocca l'icona dell'app "Tiro di dadi", il sistema Android avvia l'MainActivity dell'app.

Nel codice MainActivity, devi fornire dettagli sul layout di Activity e su come l'utente deve interagire con esso.

• Nell'app Birthday Card, c'è una Activity che mostra il messaggio e l'immagine di compleanno.
• Nell'app Tira dadi, è presente un Activity che mostra il layout TextView e Button che hai appena creato.

Per le app più complesse, potrebbero essere presenti più schermate e più di un Activity. Ogni Activity ha uno scopo specifico.

Ad esempio, in un'app galleria fotografica, potresti avere un Activity per visualizzare una griglia di foto, un secondo Activity per visualizzare una singola foto e un terzo Activity per modificare una singola foto.

Apri il file MainActivity.kt

Aggiungerai il codice per rispondere a un tocco del pulsante in MainActivity. Per farlo correttamente, devi capire meglio il codice MainActivity già presente nella tua app.

1. Vai al file MainActivity.kt (app > java > com.example.diceroller > MainActivity.kt) e aprilo. Di seguito è riportato ciò che dovresti vedere. Se vedi import..., fai clic su ... per espandere le importazioni.

package com.example.diceroller

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
   }
}

Non è necessario comprendere ogni singola parola del codice riportato sopra, ma è necessario avere un'idea generale di cosa fa. Più lavori con il codice Android, più lo conoscerai e lo comprenderai.

2. Esamina il codice Kotlin per la classe MainActivity, identificata dalla parola chiave class e poi dal nome.

class MainActivity : AppCompatActivity() {
    ...
}

3. Nota che non è presente alcuna funzione main() in MainActivity.
   
   In precedenza, hai appreso che ogni programma Kotlin deve avere una funzione main(). Le app per Android funzionano in modo diverso. Anziché chiamare una funzione main(), il sistema Android chiama il metodo onCreate() del tuo MainActivity quando la tua app viene aperta per la prima volta.
   
4. Trova il metodo onCreate(), che ha l'aspetto del codice riportato di seguito.

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)
   }

Scoprirai di più su override in un codelab successivo (quindi non preoccuparti per ora). Il resto del metodo onCreate() configura MainActivity utilizzando il codice delle importazioni e impostando il layout iniziale con setContentView().

5. Nota le righe che iniziano con import.
   

Android fornisce un framework di numerose classi per semplificare la scrittura di app per Android, ma deve sapere esattamente a quale classe ti riferisci. Puoi specificare la classe del framework da utilizzare nel codice utilizzando un'istruzione import. Ad esempio, la classe Button è definita in android.widget.Button.

Abilitare le importazioni automatiche

Può diventare molto impegnativo ricordare di aggiungere le istruzioni import quando utilizzi più classi. Fortunatamente, Android Studio ti aiuta a scegliere le importazioni corrette quando utilizzi classi fornite da altri. In questo passaggio configurerai Android Studio in modo che aggiunga automaticamente le importazioni quando possibile e rimuova automaticamente le importazioni inutilizzate dal codice.

1. In Android Studio, apri le impostazioni andando a File > Other Settings > Preferences for New Projects (File > Altre impostazioni > Preferenze per i nuovi progetti).
2. Espandi Altre impostazioni > Importazione automatica. Nelle sezioni Java e Kotlin, assicurati che le opzioni Aggiungi importazioni non ambigue al volo e Ottimizza importazioni al volo (per il progetto corrente) siano selezionate. Tieni presente che in ogni sezione sono presenti due caselle di controllo.
   
   Le impostazioni Importazioni non ambigue indicano ad Android Studio di aggiungere automaticamente un'istruzione di importazione, a condizione che possa determinare quale utilizzare. Le impostazioni Ottimizza importazioni indicano ad Android Studio di rimuovere tutte le importazioni che non vengono utilizzate dal codice.
   
3. Salva le modifiche e chiudi le impostazioni premendo Ok.

Ora che sai qualcosa in più su MainActivity, modificherai l'app in modo che, quando fai clic su Button, succeda qualcosa sullo schermo.

Visualizzare un messaggio quando si fa clic sul pulsante

In questo passaggio, specificherai che quando si fa clic sul pulsante, viene visualizzato un breve messaggio nella parte inferiore dello schermo.

1. Aggiungi il seguente codice al metodo onCreate() dopo la chiamata setContentView(). Il metodo findViewById() trova Button nel layout. R.id.button è l'ID risorsa per Button, che è un identificatore univoco. Il codice salva un riferimento all'oggetto Button in una variabile chiamata rollButton, non l'oggetto Button stesso.

val rollButton: Button = findViewById(R.id.button)

Nota: Android assegna automaticamente i numeri ID alle risorse della tua app. Ad esempio, il pulsante Roll ha un ID risorsa e anche la stringa per il testo del pulsante ha un ID risorsa. Gli ID risorsa sono nel formato R.<type>.<name>, ad esempio R.string.roll. Per gli ID View, il <type> è id, ad esempio R.id.button.

Il codice salva il riferimento all'oggetto Button in una variabile denominata rollButton, non l'oggetto Button stesso.

Importante:quando assegna un oggetto a una variabile, Kotlin non copia l'intero oggetto ogni volta, ma salva un riferimento all'oggetto. Puoi pensare a un riferimento come a un codice fiscale o a un altro numero di documento di identità nazionale: il numero si riferisce a una persona, ma non è la persona stessa. Quando copi il numero, non copi la persona.

Il metodo onCreate() ora dovrebbe avere il seguente aspetto.

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)

   val rollButton: Button = findViewById(R.id.button)
}

2. Verifica che Android Studio abbia aggiunto automaticamente un'istruzione import per Button.
   Nota che ora ci sono tre istruzioni import: la terza è stata aggiunta automaticamente.
   

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button

Nota:se l'attivazione delle importazioni automatiche non ha funzionato, Button verrà evidenziato in rosso. Puoi aggiungere manualmente l'importazione corretta posizionando il cursore di testo all'interno della parola Button, quindi premendo Alt+Enter (Option+Enter su Mac).

A questo punto devi associare il codice a Button, in modo che possa essere eseguito quando viene toccato Button. Un listener di clic è un codice che indica cosa fare quando si verifica un tocco o un clic. Puoi considerarlo come un codice che rimane inattivo, "in ascolto" del clic dell'utente, in questo caso sul Button.

3. Utilizza l'oggetto rollButton e imposta un listener di clic chiamando il metodo setOnClickListener().

rollButton.setOnClickListener {
}

Durante la digitazione, Android Studio potrebbe mostrare più suggerimenti. In questo caso, scegli l'opzione setOnClickListener {...}.

All'interno delle parentesi graffe, inserisci le istruzioni su cosa deve accadere quando viene toccato il pulsante. Per il momento, la tua app mostrerà un Toast, ovvero un breve messaggio visualizzato dall'utente.

4. Crea un Toast con il testo "Dice Rolled!" chiamando Toast.makeText().

val toast = Toast.makeText(this, "Dice Rolled!", Toast.LENGTH_SHORT)

5. Quindi, chiedi a Toast di visualizzarsi chiamando il metodo show().

toast.show()

Ecco l'aspetto della classe MainActivity aggiornata. Le istruzioni package e import si trovano ancora nella parte superiore del file:

class MainActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val rollButton: Button = findViewById(R.id.button)
       rollButton.setOnClickListener {
           val toast = Toast.makeText(this, "Dice Rolled!", Toast.LENGTH_SHORT)
           toast.show()
       }
   }
}

Puoi combinare le due righe nel listener di clic in un'unica riga senza una variabile. Si tratta di un pattern comune che potresti trovare in altri codici.

Toast.makeText(this, "Dice Rolled!", Toast.LENGTH_SHORT).show()

6. Esegui l'app e fai clic sul pulsante Roll. Un messaggio toast dovrebbe apparire nella parte inferiore dello schermo e scomparire dopo un breve periodo di tempo.

Evviva! Il clic sul pulsante ha fatto apparire il messaggio. È la prima volta che scrivi codice Kotlin per Android.

Aggiorna il TextView quando viene fatto clic sul pulsante

Anziché mostrare un messaggio temporaneo Toast, scriverai il codice per aggiornare il TextView sullo schermo quando viene fatto clic sul pulsante Tira.

1. Torna a activity_main.xml (app > res > layout >activity_main.xml)
2. Fai clic su TextView.
3. Tieni presente che l'id è textView.
   
4. Apri MainActivity.kt (app > java > com.example.diceroller > MainActivity.kt)
5. Elimina le righe di codice che creano e mostrano Toast.

rollButton.setOnClickListener {
  
}

6. Al loro posto, crea una nuova variabile denominata resultTextView per memorizzare TextView.
7. Utilizza findViewById() per trovare textView nel layout utilizzando il relativo ID e memorizza un riferimento.

val resultTextView: TextView = findViewById(R.id.textView)

8. Imposta il testo su resultTextView su "6" tra virgolette.
   

resultTextView.text = "6"

Questa operazione è simile a quella che hai eseguito impostando il testo in Attributi, ma ora si trova nel codice, quindi il testo deve essere racchiuso tra virgolette doppie. Se lo imposti in modo esplicito, per ora TextView visualizza sempre 6. Aggiungerai il codice per tirare il dado e mostrare valori diversi nella prossima attività.

Ecco come dovrebbe apparire la classe MainActivity:

class MainActivity : AppCompatActivity() {

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_main)

       val rollButton: Button = findViewById(R.id.button)
       rollButton.setOnClickListener {
           val resultTextView: TextView = findViewById(R.id.textView)
           resultTextView.text = "6"
       }
   }
}

9. Esegui l'app. Fai clic sul pulsante. Il valore di TextView dovrebbe essere aggiornato a "6".

L'unica cosa che manca è tirare i dadi. Puoi riutilizzare la classe Dice del codelab precedente, che gestisce la logica per tirare un dado.

Aggiungere la classe Dice

1. Dopo l'ultima parentesi graffa nella classe MainActivity, crea la classe Dice con un metodo roll().

class Dice(val numSides: Int) {

   fun roll(): Int {
       return (1..numSides).random()
   }
}

2. Nota che Android Studio sottolinea numSides con una linea grigia ondulata. (Potrebbe occorrere qualche istante prima che venga visualizzato).
3. Passa il puntatore sopra numSides e viene visualizzato un popup con il messaggio La proprietà "numSides" potrebbe essere privata.
   

Se contrassegni numSides come private, sarà accessibile solo all'interno del corso Dice. Poiché l'unico codice che utilizzerà numSides si trova all'interno della classe Dice, è possibile rendere questo argomento private per la classe Dice. Nella prossima unità scoprirai di più sulle variabili private e public.

4. Procedi con la correzione suggerita da Android Studio facendo clic su Rendi "numSides" "private".

Crea un metodo rollDice()

Ora che hai aggiunto una classe Dice alla tua app, aggiornerai MainActivity per utilizzarla. Per organizzare meglio il codice, inserisci tutta la logica relativa al lancio di un dado in una sola funzione.

1. Sostituisci il codice nel listener di clic che imposta il testo su "6" con una chiamata a rollDice().

rollButton.setOnClickListener {
   rollDice()
}

2. Poiché rollDice() non è ancora definito, Android Studio segnala un errore e mostra rollDice() in rosso.
3. Se passi il puntatore sopra rollDice(), Android Studio mostra il problema e alcune possibili soluzioni.

4. Fai clic su Altre azioni… per visualizzare un menu. Android Studio ti offre la possibilità di fare di più.

Suggerimento:se hai difficoltà a passare il puntatore sopra Altre azioni… e poi a fare clic, puoi fare clic su rollDice() e premere Alt+Enter (Option+Enter su Mac) per visualizzare il menu.

5. Seleziona Crea funzione "rollDice". Android Studio crea una definizione vuota per la funzione all'interno di MainActivity.

private fun rollDice() {
    TODO("Not yet implemented")
}

Crea una nuova istanza dell'oggetto Dice

In questo passaggio, farai in modo che il metodo rollDice() crei e tiri un dado, quindi visualizzerai il risultato in TextView.

1. In rollDice(), elimina la chiamata TODO().
2. Aggiungi il codice per creare un dado a 6 facce.

val dice = Dice(6)

3. Tira il dado chiamando il metodo roll() e salva il risultato in una variabile chiamata diceRoll.

val diceRoll = dice.roll()

4. Trova il TextView chiamando il numero findViewById().

val resultTextView: TextView = findViewById(R.id.textView)

La variabile diceRoll è un numero, ma TextView utilizza il testo. Puoi utilizzare il metodo toString() su diceRoll per convertirlo in una stringa.

5. Converti diceRoll in una stringa e utilizzala per aggiornare il testo di resultTextView.

resultTextView.text = diceRoll.toString()

Ecco come si presenta il metodo rollDice():

private fun rollDice() {
    val dice = Dice(6)
    val diceRoll = dice.roll()
    val resultTextView: TextView = findViewById(R.id.textView)
    resultTextView.text = diceRoll.toString()
}

6. Esegui l'app. Il risultato del dado dovrebbe cambiare in altri valori diversi da 6. Poiché si tratta di un numero casuale compreso tra 1 e 6, a volte potrebbe apparire anche il valore 6.

Evviva, sei il migliore!

È normale che il codice appaia un po' disordinato dopo aver modificato alcune parti qua e là per far funzionare l'app. Prima di abbandonare il codice, però, dovresti eseguire alcune semplici operazioni di pulizia. In questo modo, l'app sarà in buone condizioni e più facile da gestire in futuro.

Queste abitudini sono quelle che gli sviluppatori Android professionisti mettono in pratica quando scrivono il codice.

Guida di stile di Android

Quando lavori in team, è ideale che i membri del team scrivano il codice in modo simile, in modo che ci sia una certa coerenza nel codice. Per questo motivo, Android ha una guida di stile per la scrittura del codice Android, che include convenzioni di denominazione, formattazione e altre buone pratiche da seguire. Rispetta queste linee guida quando scrivi codice Android: Guida di stile Kotlin per gli sviluppatori Android.

Di seguito sono riportati alcuni modi per rispettare la guida di stile.

Ottimizzare il codice

Comprimere il codice

Puoi rendere il codice più conciso condensandolo in un numero inferiore di righe. Ad esempio, ecco il codice che imposta il listener dei clic su Button.

rollButton.setOnClickListener {
    rollDice()
}

Poiché le istruzioni per il listener di clic sono lunghe solo una riga, puoi condensare la chiamata al metodo rollDice() e le parentesi graffe in una sola riga. Ecco come si presenta. Una sola riga anziché tre.

rollButton.setOnClickListener { rollDice() }

Riformattare il codice

Ora riformatta il codice per assicurarti che segua le convenzioni di formattazione del codice consigliate per Android.

1. Nel corso MainActivity.kt, seleziona tutto il testo del file con la scorciatoia da tastiera Control+A su Windows (o Command+A su Mac). In alternativa, puoi andare al menu di Android Studio Modifica > Seleziona tutto.
2. Con tutto il testo selezionato nel file, vai al menu di Android Studio Code > Reformat Code (Codice > Riformatta codice) o utilizza la scorciatoia da tastiera Ctrl+Alt+L (o Command+Option+L su Mac).

che aggiorna la formattazione del codice, inclusi spazi vuoti, rientri e altro ancora. Potresti non notare alcuna modifica, il che è positivo. Il codice era già formattato correttamente.

Aggiungere commenti al codice

Aggiungi alcuni commenti al codice per descrivere cosa succede nel codice che hai scritto. Man mano che il codice diventa più complesso, è importante anche annotare perché hai scritto il codice in modo che funzioni in un determinato modo. Se torni al codice in un secondo momento per apportare modifiche, cosa fa il codice potrebbe essere ancora chiaro, ma potresti non ricordare perché lo hai scritto in quel modo.

È prassi comune aggiungere un commento per ogni classe (MainActivity e Dice sono le uniche classi presenti nella tua app) e per ogni metodo che scrivi. Utilizza i simboli /** e **/ all'inizio e alla fine del commento per indicare al sistema che non si tratta di codice. Queste righe verranno ignorate quando il sistema esegue il codice.

Esempio di commento su un corso:

/**
* This activity allows the user to roll a dice and view the result
* on the screen.
*/
class MainActivity : AppCompatActivity() {

Esempio di commento su un metodo:

/**
* Roll the dice and update the screen with the result.
*/
private fun rollDice() {

All'interno di un metodo, puoi aggiungere commenti se possono essere utili al lettore del tuo codice. Ricorda che puoi utilizzare il simbolo // all'inizio del commento. Tutto ciò che segue il simbolo // su una riga viene considerato un commento.

Esempio di due commenti all'interno di un metodo:

private fun rollDice() {
   // Create new Dice object with 6 sides and roll it
   val dice = Dice(6)
   val diceRoll = dice.roll()

   // Update the screen with the dice roll
   val resultTextView: TextView = findViewById(R.id.textView)
   resultTextView.text = diceRoll.toString()
}

1. Prenditi un po' di tempo per aggiungere commenti al tuo codice.
2. Con tutte queste modifiche ai commenti e alla formattazione, è buona norma eseguire di nuovo l'app per assicurarsi che funzioni ancora come previsto.

Visualizza il codice della soluzione per un modo in cui avresti potuto commentare il tuo codice.

Il codice della soluzione per questo codelab si trova nel progetto e nel modulo mostrati di seguito.

URL del codice della soluzione: https://github.com/google-developer-training/android-basics-kotlin-create-dice-roller-with-button-app-solution

Per ottenere il codice di questo codelab da GitHub e aprirlo in Android Studio, procedi nel seguente modo.

1. Avvia Android Studio.
2. Nella finestra Welcome to Android Studio (Benvenuto in Android Studio), fai clic su Check out project from version control (Estrai progetto dal controllo della versione).
3. Scegli Git.

4. Nella finestra di dialogo Clona repository, incolla l'URL del codice fornito nella casella URL.
5. Fai clic sul pulsante Test, attendi e assicurati che venga visualizzata una bolla popup verde con il messaggio Connessione riuscita.
6. (Facoltativo) Modifica la directory con un valore diverso da quello predefinito suggerito.

7. Fai clic su Clona. Android Studio inizia a recuperare il codice.
8. Nel popup Checkout dal controllo della versione, fai clic su Sì.

9. Attendi l'apertura di Android Studio.
10. Seleziona il modulo corretto per il codice di avvio o la soluzione del codelab.

11. Fai clic sul pulsante Esegui per creare ed eseguire il codice.

Guida:consulta la Guida alla risoluzione dei problemi se il codice scaricato non viene caricato o eseguito correttamente.

• Aggiungi un Button in un'app per Android utilizzando l'editor layout.
• Modifica la classe MainActivity.kt per aggiungere un comportamento interattivo all'app.
• Visualizza un messaggio Toast come soluzione temporanea per verificare di essere sulla strada giusta.
• Imposta un listener di clic per un Button utilizzando setOnClickListener() per aggiungere un comportamento quando viene fatto clic su un Button.
• Quando l'app è in esecuzione, puoi aggiornare lo schermo chiamando i metodi su TextView, Button o altri elementi UI nel layout.
• Commenta il tuo codice per aiutare le altre persone che lo leggono a capire il tuo approccio.
• Riformatta il codice e puliscilo.

• Button
• Toast
• TextView
• Guida di stile di Kotlin per gli sviluppatori Android

Nota: le pratiche sono facoltative. Ti offrono l'opportunità di mettere in pratica ciò che hai imparato in questo codelab.

Procedi nel seguente modo:

1. Aggiungi un altro dado all'app. Se fai clic sul pulsante Tira, dovresti tirare due dadi. I risultati devono essere visualizzati sullo schermo in due TextViews diversi.

Controllare il lavoro:

L'app finita deve essere eseguita senza errori e mostrare due dadi.