Emulando Android… Costruire un’app partendo da zero: la “Magic 8 Ball”

Spesso chi è attratto dal funzionamento dei sistemi operativi o coloro che si dedicano alla sicurezza degli stessi tendono ad utilizzare strumenti per emulare tali sistemi e metterli alla prova. Esistono degli emulatori che permettono di fare tutto questo testando Android, come vedremo, in un ambiente sicuro senza mettere a rischio il proprio dispositivo. Per definizione, un emulatore è un software che permette di simulare, o in certi casi tradurre, il comportamento di un sistema operativo così da poterlo mettere alla prova, oppure semplicemente utilizzare senza installarlo.

Probabilmente, il software più conosciuto in questo ambito è Virtual Box (di cui abbiamo parlato in più riprese, qui e un bel po’ di tempo, in un altro contesto, ovvero quello dei videogiochi su Linux, anche e già occupati di un altro emulatore denominato Wine), ma oggi daremo un’occhiata ad un altro tipo di emulatore particolarmente adatto nel caso volessimo creare e testare un’applicazione senza la necessità di utilizzare fisicamente il nostro smartphone, stiamo parlando di Android Studio; è gratuito, utilizzabile e scaricabile per i seguenti sistemi operativi: Windows, Linux, Mac, Chrome OS.

Android Studio ci permette di avere a nostra disposizione un emulatore che ha quasi tutte le capacità in virtuale di uno strumento Android reale: possiamo, infatti, simulare la ricezione di chiamate e di sms, specificare la localizzazione, provare ad utilizzare diverse velocità di rete, simulare la rotazione dello schermo ed utilizzare altri sensori network, etc.

Ma proviamo a dare un’occhiata a come funziona e proviamo, perché no, a costruire una semplice applicazione passo per passo. Solitamente per cominciare ad imparare ad utilizzare Android Studio si inizia con la classica applicazione del biglietto d’auguri, oppure del dado; noi, abbiamo deciso di fare qualcosa di simile che non tutti conoscono: la “Magic 8 Ball”, nel mondo fisico questa è una palla da 8 del biliardo che, però, scuotendola dà delle risposte casuali (generalmente, sono circa venti diverse risposte); qui creeremo un’applicazione molto semplice e basilare per lo smartphone che la ricorda. Ovviamente, questo codice potrà essere in futuro migliorato e sviluppato di modo da rendere l’applicazione più interattiva, ma il nostro obiettivo in questa sede è di introdurre le basi.

Non è necessario conoscere bene il linguaggio di programmazione per iniziare perché l’interfaccia programmerà al posto nostro le azioni che metteremo in forma all’interno della schermata di costruzione, ma logicamente dovremo riuscire già a comprendere a grandi linee come muoverci.

Ricordiamoci, comunque, che senza uno scopo ben prefissato ed un’idea ben chiara di che tipo di applicazione vogliamo creare non porteremo mai a termine quello che abbiamo iniziato.

La prima cosa che possiamo notare non appena apriamo Android Studio è la presenza di Template, ovvero dei modelli preimpostati da cui attingere, così da non partire da zero con la creazione della nostra applicazione, un po’ come accade quando scegliamo un modello di Word con un’impaginazione particolare già bello che pronto in cui, poi, inseriamo il nostro testo. Creiamo un nuovo progetto andando sulla barra delle applicazioni in alto a sinistra e scegliamo File, poi New (nuovo) e New Project (nuovo progetto).

Scegliamo quindi un Template. Ci siamo già prefissati, qui, cosa vogliamo fare: partiremo, quindi, da una pagina completamente bianca e sceglieremo il nome da darle.

A questo punto dobbiamo decidere per quale tipo di Android far funzionare l’applicazione: è importante, infatti, comprendere che un sistema operativo troppo vecchio oppure troppo nuovo potrebbe non funzionare con la nostra app. Di conseguenza, cercheremo di scegliere di costruire un’app che sia adeguata ad almeno il 98% degli Android utilizzati sul mercato, ovvero la versione Android 5.0 (Lollipop).

Ora, dopo alcuni secondi di caricamento si aprirà una nuova finestra con tutto ciò che ci serve. Fermiamoci ad osservarne per un attimo la colonna alla nostra sinistra dove troveremo:
app > java > com.example.myfirstapp > MainActivity ovvero la parte che si occupa dell’attività principale della nostra applicazione. Il momento in cui costruiremo e proveremo l’applicazione questa è l’istanza che si occuperà del lancio del layout.
app > res > layout > activity_main.xml qui abbiamo l’XML file, che è un po’ come il cacio sui maccheroni, e che definisce il layout relativo all’interfaccia utente. Qui troviamo l’elemento TextView dove vi è “Hello, World!”
app > manifests > AndroidManifest.xml questo descrive le caratteristiche fondamentali e definisce i componenti della nostra applicazione.
Gradle Scripts > build.gradle in questo caso abbiamo due file con lo stesso nome, il primo per il nostro progetto, mentre il secondo relativo al suo modulo; ogni modulo ha il proprio file build.gradle (per il momento ne abbiamo uno solo). Ogni modulo viene utilizzato per controllare come il plugin di Grandle configura la nostra applicazione.

Clicchiamo, poi, sulla barra delle applicazioni Run e Run App così da accedere al nostro emulatore a forma di smartphone che possiamo osservare nell’immagine qui sotto posizionato sulla nostra destra.

Per iniziare, quindi, ad impostare una piccola e semplice interfaccia, spostiamoci sulla colonna di sinistra accedendo al menu a cascata su app > res > layout > activity_main.xml

A questo punto dovremo spostare le colonne della pagina così da rendere più semplice la navigazione ed il nostro lavoro che continuerà sulla colonna che nel nostro caso abbiamo lasciato centrale e che coincide con activity_main.xml.

Per comodità lavoreremo direttamente sulla schermata dedicata al blueprint che potremo selezionarla cliccando in alto sull’icona blu che assomiglia a due piani romboidali posti l’uno sopra l’altro.

La prima cosa che faremo se vogliamo, per esempio, costruire una schermata semplice con un titolo sarà andare su Text e trascinare Plain Text sul luogo che più ci aggrada della schermata blueprint; dopodiché faremo la medesima cosa cliccando su Buttons (bottoni) e Button (bottone) trascinandolo accanto al testo che abbiamo aggiunto.

A questo punto, utilizzando la colonna di sinistra vedremo che potremo inserire un testo qualsiasi, oppure con e-mail, la possibilità di inserimento di password o password numerica, ed altri bottoni, ovvero tutto ciò che ci servirebbe se volessimo creare il login per la nostra applicazione. Ma, saltiamo questo passaggio e dedichiamoci direttamente alla costruzione della schermata che ci interessa.

PRIMO PASSO: COME AGGIUNGERE UN TASTO ALL’APPLICAZIONE

Per definizione, un tasto è un’interfaccia utente (UI), ovvero un elemento che permette all’utente di interagire con l’applicazione per performare un’azione. Creiamo, quindi, un bel tasto che inviti l’utente a cliccare per “shakerare” la nostra Magic 8 ball.
Per farlo nella sezione activity_main.xml selezioniamo nella colonna “Palette” la dicitura “Button” (Tasto) e trasciniamolo sotto alla scritta già preimpostata “Hello World!” di modo che vada a far parte del “ConstraintLayout” presente nella colonna sulla parte destra, al centro della schermata. Possiamo anche cambiarne il nome cliccando sul tasto che abbiamo aggiunto: sulla colonna di sinistra comparirà, infatti, “Declared Attributes” (attributi dichiarati) e su text potremo scrivere, per esempio, “Scuotimi!”.

Ora, notiamo sulla colonna “ConstraintLayout” la presenza di una piccola icona rossa con un punto esclamativo proprio accanto alla scritta “Button” che ci segnala la presenza di un errore ed il suggerimento per correggerlo, ovvero “This view is not constrained. It only has design time positions, so it will jump to (0,0) at runtime unless you add the constraints”, ovvero “Questa rapprentazione non è vincolata. Ha solo localizzazioni temporali in fase di progettazione, quindi passerà a (0,0) in fase di esecuzione a meno che non si aggiungano i vincoli”, ergo dobbiamo aggiungere dei vincoli, o “constraints”.

Come fare? Abbiamo preso, per pigrizia, in prestito la .gif di Android Studio per mostrare come fare con facilità: basterà selezionare il nostro bel tasto, cliccare sulla pallina che comparirà al centro e, mantenendo la selezione, spostarla verso quella che comparirà su “Hello World”; in questo modo vincoleremo il tasto, in verticale, alla scritta menzionata spostandolo anche ed automaticamente accanto ad essa. A questo punto, molto probabilmente, se aggiornassimo la visione dell’applicazione sul nostro Android virtuale il tasto del nostro “Scuotimi!” si troverebbe all’estrema sinistra dello schermo, per ovviare a questo dovremo cliccare con il tasto destro del mouse sul tasto, dal menu che comparirà scegliere “Center” e “Horizontaly” di modo da spostare al centro il nostro tasto.

COME IMPLEMENTARE IL TASTO

La logica di questa applicazione è la stessa che incontriamo quando lanciamo un dado, solo che invece di ricevere in risposta un numero, troviamo una frase.

Sulla colonna di sinistra, nel nostro menu, selezioniamo app > java > com.example.magic8ball > MainActivity, così da aprire al centro il luogo dove andremo a scrivere i passaggi logici che ci servono per far funzionare l’applicazione.

Prima di tutto, quando programmiamo, ricordiamoci sempre di commentare i vari passaggi: questa è un’ottima pratica per permetterci una veloce revisione di ciò che abbiamo fatto, una più precisa correzione dei potenziali errori ed anche la possibilità di recuperare un vecchio programma e riadattarlo per un nuovo e diverso proposito. Generalmente, a seconda del linguaggio utilizzato i commenti possono essere introdotti con // oppure # o ancora /**

Vediamo di rendere interattivo il tasto che abbiamo aggiunto di modo che, una volta schiacciato “Scuotimi”, l’applicazione ci risponda: “Eccoti la risposta!”

Quando accediamo a MainActivity.kt troviamo un principio di codice già preimpostato che sarà il seguente:

package com.example.myapplication

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)
}
}

Partendo da questa pre-impostazione, inizieremo ad aggiungere il nostro codice per “insegnare” alla nostra applicazione a risponderci quando il tasto è stato utilizzato. A questo punto aggiungeremo due passaggi che saranno riportati nel codice alla fine del paragrafo in grassetto.

  1. Della pre-impostazione non cancelleremo nulla: dopo a setContentView( ) utilizzeremo la variabile rollButton (in cui è salvato automaticamente un riferimento all’oggetto “Tasto” e che permette a Kotlin di non andare a copiare l’oggetto stesso ogni qualvolta ne necessiti il richiamo) che andrà a dire alla nostra applicazione di trovare e pescare il nostro Tasto dal layout con findViewById( ), mentre R.id.button fungerà da fonte identificativa ed unica del tasto stesso (Android, infatti, assegna dei numeri identificativi, ID, a tutte le fonti interne alla nostra applicazione).
  2. Ora, dovremo associare il codice con il tasto cosicché esso venga eseguito nel momento in cui l’utente lo clicca; in altre parole, aggiungeremo un’impostazione che ascolti ciò che l’utente le chiede usando setOnClickListener seguito da delle parentesi graffe in cui scriveremo le istruzioni su ciò che dovrà accadere come risposta, ovvero utilizzeremo Toast che altro non è che il messaggio da noi prescelto “Ecco la risposta!”.
  3. Infine, diremo a Toast di mostrarsi sullo schermo con toast.show ()
package com.example.myapplication

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)

        val rollButton: Button = findViewById(R.id.button)
        rollButton.setOnClickListener {
   
        val toast = Toast.makeText(this, "Ecco la risposta!",Toast.LENGHT_SHORT).show()
}

    }
}

Nel caso LENGHT_SHORT risultasse scritto in rosso, come nel caso di qualsiasi altro errore che possa mostrarsi in tal modo, basterà evidenziarlo e cliccare il tasto ALT assieme ad Invio di modo da poter selezionare la risposta corretta e correggere l’errore.

Inoltre, un altro passaggio potrà essere quello di sostituire val toast con:

val resultTextView: TextView = findViewById(R.id.textView2)
resultTextView.text = "Per quanto ne so, sì"

Oppure, se la nostra intenzione è mantenere la scritta “Ecco la risposta” basterà aggiungere tale codice al di sopra della stringa val toast. Ricordiamoci, come precedentemente accennato che R.id. in questo caso textView2 coinciderà con l’ID presente nella colonna della scritta in cui vogliamo apporre la risposta “Per quanto ne so, sì” che nel nostro caso sostituisce “Hello world!” che abbiamo cancellato. Oltre a questo abbiamo ingrandito la scritta e modificato il font: nell’immagine sottostante viene indicato con le frecce dove è possibile trovare tutte queste informazioni.

COME AGGIUNGERE I VARI PASSAGGI LOGICI COMPLETI DI IMMAGINI ALLA NOSTRA APPLICAZIONE E MODIFICARLA A NOSTRO PIACIMENTO

Adesso che abbiamo impostato il tasto ed un’ipotetica risposta dovremo generare tutti i potenziali passaggi logici e le venti diverse risposte casuali che l’applicazione Magic 8 Ball dovrà darci. Oltre a questo potremo implementare ulteriormente il nostro gioco, magari modificando lo “Scuotimi” con “Pensa ad una domanda e clicca”, o con ciò che più preferiamo di più.

Nella nostra applicazione, per darle un’idea più interattiva, abbiamo deciso di aggiungere le risposte inserendole all’interno di un’immagine della Magic Ball, per cui i passaggi logici da seguire saranno relativi a questo particolare step. Dovremo, quindi e come prima cosa, occuparci della creazione della immagini, oppure scaricarle da internet già pronte ed in seguito, caricarle sulla nostra applicazione per far coincidere immagine e risposta.

Abbiamo recuperato una Magic8Ball vuota (la stessa che vediamo postata in questo paragrafo) ed abbiamo creato, con un editor per immagini, le venti diverse risposte inserendole al suo interno e salvandole singolarmente e, per comodità, numerandole. Logicamente, salteremo la spiegazione su come modificare ed editare le immagini poiché, in questo specifico caso ed occupandoci di programmazione, ci sembra abbastanza banale.

Aggiungiamo allora le immagini che abbiamo preparato: spostiamoci sulla barra della applicazioni di Android Studio, selezioniamo View -> Tool Windows -> Resource Manager (Vista -> Strumenti Windows -> Gestione Risorse).

A lato, sulla nostra estrema sinistra comparirà l’icona + che andremo a selezionare, scegliendo Import Drawables (Importa Immagini). Si aprirà una nuova finestra in cui potremo andare a cercare ed aggiungere, ad una ad una, le immagini che abbiamo predisposto precedentemente: per continuare ad importare su Android Studio i files basterà cliccare in alto a destra di tale finestra su Import more files (importa altri files).

Una volta fatto ciò e cliccato sull’Ok, compariranno, sulla nostra colonna di sinistra, tutte le immagini che abbiamo importato e caricato sul software; per controllare che tutto sia avvenuto in maniera corretta possiamo, anche, dare un’occhiata sempre sulla nostra colonna di sinistra cliccando su Project (Progetto, la piccola scritta posizionata in verticale), andare alla voce app -> res -> drawable dove troveremo l’elenco di tutte le nostre immagini che, ora, andremo ad aggiunere nel nostro codice utilizzando il loro ID che, nel nostro caso, è dato dal nome dei files anticipato da R.drawable. avremo, quindi, e per esempio R.drawable.m1 in cui m1 è l’ID della nostra prima immagine.

A questo punto, torneremo sul nostro activity_main.xml, aggiungeremo l’immagine e la moduleremo, spostandola, rimpiccolendola o ingrandendola, a nostro piacimento e come avevamo precedentemente fatto con il nostro tasto.

Ed ora, dedichiamoci finalmente al codice tornando sulla sezione MainActivity.kt.

Per comodità, abbiamo fatto delle piccole modifiche al codice di partenza, aggiungendo qua e là anche qualche commento che ci aiuti a comprendere la presenza di alcuni comandi e lo sviluppo dell’applicazione stessa. Questi commenti vengono introdotti da /** e chiusi con */, sono inoltre facili da notare poiché evidenziati automaticamente in colore verde sul nostro Android Studio (qui sotto li abbiamo riportati in grossetto per rendere più semplice la lettura del codice e per farne notare la sua divisione logica).

Come possiamo vedere qui sotto abbiamo eliminato il toast, ovvero l’avviso che compariva sullo schermo una volta cliccato il tasto poiché non più necessario volendo inserire direttamente l’immagine-risposta.

Nella prima parte di ogni applicazione vengono introdotte, come avevamo visto in passato, le librerie necessarie a cui il nostro programma deve appoggiarsi per funzionare; nal caso di Kotlin utilizziamo l’importazione (import). In specifico i passaggi logici per creare, di norma, un’applicazione Android sono i seguenti:

  1. Scegliamo su quali sistemi Android l’applicazione potrà funzionare
  2. Impostiamo la grafica dell’interfaccia
  3. Introduciamo le librerie d’appoggio che ci permetteranno di far funzionare il mio sistema
  4. Impostiamo i tasti di utilizzo e le loro dipendenze assieme a quelle dell’interfaccia grafica
  5. Generiamo il corpo dell’applicazione con tutte le sue risposte alle potenziali richieste dell’utente
  6. Chiudiamo l’applicazione
  7. Controlliamo che non ci siano errori e che tutto funzioni fluidamente

Dopo aver impostato le librerie, inizieremo ad impostare l’attività. Qui noteremo l’utilizzo della classe “MainActivity”, ovvero dell’attività principale; per definizione la classe è composta da un gruppo di oggetti appartenenti alla nostra interfaccia che presentano le stesse caratteristiche e funzionalità. Nel nostro caso è presente un tasto e delle immagini comuni della Magic8Ball, ma potrebbe esserci anche e per esempio un menu, una finestra, un testo, delle linee, etc.

Immagine presa in prestito da https://developer.android.com/guide/components/activities/activity-lifecycle

AppCompactActivity è un’altra classe che ci permette invece di utilizzare alcune delle nuove potenzialità di Android anche all’interno di vecchie piattaforme e, di conseguenza, ci dà la possibilità di usare la nostra applicazione anche su Android più obsoleti. Con l’espressione “class MainActivity : AppCompatActivity()” stiamo semplicemente dichiarando che il nome della classe MainActivity utilizza il tipo di classe AppCompactActivity.

L’immagine del diagramma di flusso, qui accanto, è particolarmente utile per aiutarci a comprendere il ciclo vitale dell’attività di un’applicazione e per ricordarci come procedere nella creazione della stessa. Inizialmente, quindi, dobbiamo lanciare l’attività come abbiamo fatto richiamando libreria ed impostando la classe principale. Dopodiché abbiamo la fase di onCreate() in cui iniziamo effettivamente a creare la logica iniziale di ciò che deve accadere una sola volta nel ciclo dell’attività della nostra applicazione che, nel nostro caso, coincide con l’uso del tasto di lancio. Questo metodo ha il parametro savedInstanceState che è un oggetto (Bundle, ovvero fasciato) che contiene lo stato dell’attività precedentemente salvata.

In questa fase dichiariamo anche che l’attività dovrà andare a pescare il nostro layout XML dove abbiamo generato l’interfaccia grafica con la dicitura “setContentView(R.layout.activity_main)”, dove activity_mail è esattamente il nome del file menzionato che avevamo creato in formato .xml quando stavamo impostando nel paragrafo precedente “Come aggiungere un tasto all’applicazione”.


/**
 * PRIMA PARTE
 * INTRODUZIONE DELL'APPLICAZIONE
 */

package com.example.magic8ball

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

/**
 * Questa attività permette all'utente di cliccare il tasto e vederne
 * la risposta sullo schermo.
 */
class MainActivity : AppCompatActivity() {

    /**
     * Inizio a creare l'attività
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        /**
         * Cerco il tasto nel layout e lo imposto di modo che reagisca alla mia chiamata
         */
        val rollButton: Button = findViewById(R.id.button)
        rollButton.setOnClickListener { rollMagic8Ball() }
        rollMagic8Ball()
    }

Questo è il momento in cui aggiungiamo la parte dedicata alle venti risposte randomiche inviate dall’applicazione attraverso le immagini che abbiamo precedentemente caricato.

Ci sono due metodi, entrambi corretti, per farlo, il classico if… else oppure when… else. Prima di vedere cosa abbiamo scelto di fare nella nostra applicazione diamo un’occhiata alle due diverse opzioni:

/**
 * Metodo nr. 1 
 * if... else 
*/
if (magic8ballRoll == 1) {
   magic8ballImage.setImageResource(R.drawable.m1)
} else if (magic8ballRoll == 2) {
   magic8ball.setImageResource(R.drawable.m2)
}
 ...

/**
 * Metodo nr. 2 
 * when... else 
*/
when (magic8ballRoll) {
       1 -> magic8ballImage.setImageResource(R.drawable.m1)
       2 -> magic8ballImage.setImageResource(R.drawable.m2)
       else -> magic8ballImage.setImageResource(R.drawable.m3) 
   }

Noi abbiamo deciso di rendere ancora più scarno il nostro codice e semplificarlo ulteriormente che, per quanto riguarda il nostro punto di vista, dovrebbe essere lo scopo di qualsiasi programmatore creare dei programmi puliti, semplici e di chiara comprensione poiché questo permette, in seconda istanza, di individuare più velocemente bug ed errori, nonché di effettuare aggiornamenti e correzioni necessari. Quindi, non solo abbiamo scelto il metodo che sembra meno verboso when… else ma, per esempio, comparendo per più volte setImageResource abbiamo risolto la ridondanza aggiungendo in fondo al codice magic8ballImage.setImageResource(drawableResource) di modo che si aggiorni il corretto ID dell’immagine senza doverlo ripetere in continuazione ad ogni stringa.

/**
 * SECONDA PARTE 
 * IL CORPO DELL'APPLICAZIONE
*/

            private fun rollMagic8Ball() {
            /** Creiamo l'oggetto Magic8Ball con 20 possibili risposte
             *
             */
            val magic8ball = Magic8Ball(20)
            val magic8ballRoll = magic8ball.roll()

            /** Il programma cerca l'immagine, ImageView, nel layout
             *
             */
            val magic8ballImage: ImageView = findViewById(R.id.imageView)

            /** Determiniamo quale immagine verrà scelta utilizzando il suo ID
             *
             */
            val drawableResource = when (magic8ballRoll) {
                1 -> R.drawable.m1
                2 -> R.drawable.m2
                3 -> R.drawable.m3
                4 -> R.drawable.m4
                5 -> R.drawable.m5
                6 -> R.drawable.m6
                7 -> R.drawable.m7
                8 -> R.drawable.m8
                9 -> R.drawable.m9
                10 -> R.drawable.m10
                11 -> R.drawable.m11
                12 -> R.drawable.m12
                13 -> R.drawable.m13
                14 -> R.drawable.m14
                15 -> R.drawable.m15
                16 -> R.drawable.m16
                17 -> R.drawable.m17
                18 -> R.drawable.m18
                19 -> R.drawable.m19
                else -> R.drawable.m20
            }
            /** Aggiorniamo l'ImageView con la corretta ID dell'immagine
             *
             */
            magic8ballImage.setImageResource(drawableResource)
        }
    }

A questo punto se ci fermiamo qui, molti alle prime armi noteranno che Android Studio segnala la mancanza della presenza di una classe; cliccando sull'errore sarà possibile aggiungerla automaticamente alla fine del nostro codice senza troppi problemi ed è esattamente quella parte che ci permetterà di concludere il ciclo della nostra semplice applicazione:
/**
 * TERZA PARTE 
 * LA CHIUSURA DELL'APPLICAZIONE
*/

class Magic8Ball(private val numSides: Int) {
    fun roll(): Int {
        return (1..numSides).random()
    }
}

Dopo aver concluso di scrivere il nostro codice, controllato gli eventuali errori o le inesattezze segnalateci da Android Studio potremo tentare di avviare il nostro piccolo programma, tenendo d’occhio il log degli eventi nel caso incappassimo in qualche malfunzionamento dell’applicazione e dovessimo cercare di comprenderne le cause. Per avviare virtualmente l’applicazione basterà andare in alto, sulla barra delle applicazioni, cliccare su “Run” e “Run app”, comparirà sulla nostra destra una nuova finestra che caricherà uno smartphone virtuale con cui potremo interagire direttamente osservando come e se la nostra applicazione risponde ai comandi.

CONSIGLI UTILI PER LA PROGRAMMAZIONE E PER EVITARE/CORREGGERE GLI ERRORI

Ci sono pochi e piccoli dettagli di cui tener conto per correggere od evitare errori, considerando che di norma sono sempre gli stessi, per lo più imputabili a distrazioni e pigrizia:

  • scriviamo sempre e manualmente il nostro codice, evitiamo di copiare ed incollare: questo ci aiuterà a muoverci meglio e memorizzare i vari passaggi necessari per costruire altre future applicazioni;
  • tutte le parentesi che si aprono devono anche chiudersi: controlliamo quindi di non averne dimenticata qualcuna in giro;
  • a volte, senza accorgercene e proprio a causa di una chiusura di parentesi, ci ritroviamo a creare ridondanze nel nostro codice di programmazione: proviamo a vedere se abbiamo fatto qualche errore chiudendo, per esempio, una parentesi un po’ troppo presto;
  • controlliamo che non ci siano parentesi in più rispetto a quelle che ci servono;
  • controlliamo che l’uso delle maiuscole e delle minuscole nel nostro programma siano usate correttamente;
  • usiamo i commenti: ci aiuteranno molto a gestire e correggere il programma, soprattutto in presenza della creazione di un software più complicato di quello che abbiamo creato qui;
  • nel caso dovesse presentarsi un errore del tipo “EditText editable is deprecated” basterà andare su activity_main.xml e modificare android:inputType come segue:
android:inputType="none"

Ora possiamo provare ad utilizzare la nostra applicazione e controllare eventuali errori di battitura oppure continuare a rifinirla rendendola graficamente più interessante, aggiungendo suoni, modificando font, colori ed altri effetti!

Share the love

Comincia la discussione

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.