Introduzione a Kotlin

IV parte: Sviluppo di applicazioni Androiddi

Introduzione

Come accennato nel primo articolo di questa serie, dal maggio 2017 Kotlin è ufficialmente supportato da Android Studio 3.0, e il sito ufficiale di Android offre una sezione specifica per iniziare a sviluppare applicazioni mobili con questo linguaggio [1]. In questa ultima parte della nostra guida introduttiva a Kotlin, andiamo a dimostrare come affrontare i primi passi per costruire un’applicazione Android con Kotlin e Android Studio.

Come nell’articolo precedente, costruiremo una semplice applicazione per visualizzare le quotazioni delle principali criptovalute utilizzando l’API offerta da CoinMarketCap [4]. Il codice completo dell’applicazione è disponibile su Github [9].

 

Creiamo lo scheletro dell’applicazione con Android Studio 3.0

Il primo passo consiste nell’installare Android Studio dal sito ufficiale [2]; l’ambiente di sviluppo è disponibile per Windows, Mac OS e Linux, ed è basato sulla stessa piattaforma utilizzata da JetBrains IntelliJ Idea. Prima di iniziare ad utilizzare l’ambiente di sviluppo, è consigliabile consultare il sito ufficiale che offre moltissime pagine di documentazione [3] su ogni aspetto di sviluppo, test e pubblicazione di applicazioni mobili.

Creare un progetto Kotlin

Una volta installato e avviato l’ambiente di sviluppo, è possibile creare un progetto Kotlin scegliendo l’opzione “Start a new Android Studio project” dal menù principale. Nella schermata successiva, selezioniamo l’opzione “Include Kotlin support” come mostrato dalla figura 1.

Figura 1 – Creazione di un progetto Android in Kotlin.

Figura 1 – Creazione di un progetto Android in Kotlin.

 

Scegliamo quindi la versione minima di Android da supportare (figura 2).

Figura 2 – Selezione della versione di Android.

Figura 2 – Selezione della versione di Android.

 

Selezioniamo poi “Basic Activity” come modello dell’applicazione (figura 3).

Figura 3 – Selezione di Basic Activity come modello di applicazione.

Figura 3 – Selezione di Basic Activity come modello di applicazione.

 

Infine accettiamo le opzioni di default nella schermata finale, prima di cliccare su “Finish”.

Figura 4 – Configurazione della Main Activity

Figura 4 – Configurazione della Main Activity

 

Una volta cliccato su “Finish”, Android Studio genererà il progetto completo: il processo richiede qualche minuto, al termine del quale si ottiene uno scheletro completo dell’applicazione pronto ad essere eseguito (figura 5).

Figura 5 – Scheletro del progetto Android

Figura 5 – Scheletro del progetto Android

Gli elementi del progetto

Diamo una prima occhiata al progetto generato:

  • la cartella app/java contiene il codice Java/Kotlin dell’applicazione; notiamo che la classe MainActivity è effettivamente in Kotlin! Come detto in precedenza, Android Studio supporta nativamente il linguaggio, ed è possibile nello stesso progetto avere codice in Java e Kotlin;
  • nella stessa cartella, la procedura guidata per la generazione dell’applicazione ha creato anche due classi di test, sempre in Kotlin: ignoreremo queste due classi nel nostro esempio introduttivo;
  • la cartella res contiene le risorse dell’applicazione: layout degli schermi, immagini, configurazioni;
  • il progetto comprende anche i build script in gradle per compilare l’applicazione e installarla sull’emulatore o su un dispositivo mobile

Prima di procedere con lo sviluppo, verifichiamo che la nostra applicazione sia stata generata correttamente cliccando sull’icona Run ‘app’ sulla barra dei comandi: una volta confermato che vogliamo eseguire l’applicazione sull’emulatore pre-installato (che sarà disponibile sotto la voce Available Virtual Devices), apparirà una schermata simile a quella mostrata in figura 6.

Figura 6 – Scheletro dell’applicazione eseguito dall’emulatore Android.

Figura 6 – Scheletro dell’applicazione eseguito dall’emulatore Android.

 

Client Android per CoinMarketCap API

Visto che l’obiettivo di questo articolo è fornire semplicemente alcuni spunti per iniziare a utilizzare Kotlin per lo sviluppo di applicazioni Android (MokaByte offre già numerosi articoli e guide su Android [8]), andremo a semplificare notevolmente l’applicazione rispetto a quanto sviluppato nella terza puntata di questa serie, accontentandoci di caricare e visualizzare le quotazioni delle principali criptovalute.

Volley

Il primo passo è implementare il client per la REST API fornita da CoinMarketCap: a questo scopo introduciamo una libreria sviluppata da Google chiamata Volley. Presentata nel 2013, l’obiettivo principale di questa libreria è velocizzare lo sviluppo di applicazioni che utilizzano frequentemente chiamate HTTP verso server esterni, allo stesso tempo supportando molte funzionalità avanzate come chiamate asincrone, caching, debugging e tracing.

I concetti di base per utilizzare Volley sono semplici:

  • esiste una (idealmente unica) RequestQueue che gestisce ed esegue tutte le chiamate HTTP/HTTPS di un’applicazione;
  • da qualsiasi punto dell’applicazione possiamo passare una Request alla RequestQueue, specificando due listener che verranno richiamati, rispettivamente, in caso di risposta positiva o errore;
  • esistono vari sottotipi di Request che ci permettono di gestire risposte in formati standard in modo semplificato (esempi: ImageRequest, StringRequest, JsonObjectRequest, JsonArrayRequest, …).

L’implementazione del client

Armati di questi concetti di base, possiamo scrivere un’implementazione estremamente compatta del nostro client:

fun RequestQueue.publishQuote(symbol: String, textView: TextView) {
  val jsonObjectRequest = JsonArrayRequest(
     Request.Method.GET,
     "https://api.coinmarketcap.com/v1/ticker/?limit=20",
     null,
     Response.Listener { response ->
       for (i in 0..(response.length() - 1)) {
         val quote = response.getJSONObject(i)
         if (quote.getString("symbol") == symbol.toUpperCase())
           textView.text = quote.getString("price_usd") + " USD"
       }
     },
     Response.ErrorListener { error ->
       Log.v("PUBLISH_QUOTE", error.toString())
     }
  )
  this.add(jsonObjectRequest)
}

Per prima cosa, notiamo che abbiamo utilizzato una extension function per aggiungere la nostra funziona publishQuote direttamente alla RequestQueue di Volley. Come già visto negli articoli precedenti, le extension function sono una delle funzionalità più utili in Kotlin per semplificare il codice e ridurre il numero di parametri passati alle funzioni.

Nella nostra funzione, creiamo un’istanza di una JsonArrayRequest, visto che la CoinMarketCap API restituisce un JSON array con le quotazioni delle principali criptovalute. Il costruttore della classe JsonArrayRequest richiede cinque parametri:

  • il metodo HTTP della chiamata (GET, nel nostro caso);
  • l’URL da chiamare;
  • il body della richiesta (che non specifichiamo, visto che nel nostro caso la richiesta è una GET);
  • il listener che verrà chiamato da Volley nel caso in cui la richiesta abbia successo; nel nostro caso il listener troverà la quotazione desiderata e ne inserirà il valore nella TextView passata come argomento alla funzione;
  • il listener eseguito da Volley in caso di errore.

Attenzione alla vecchia sintassi…

Come si può notare, il codice è abbastanza semplice e compatto: l’unica nota “stonata”, per sviluppatori che abbiano preso un po’ di dimestichezza col codice Kotlin, è il ciclo for all’interno del Response Listener che utilizza la vecchia sintassi for..loop di Java: non possiamo infatti utilizzare nessuno dei normali costrutti di Kotlin per scorrere tutti gli elementi dell’array perché la classe JSONArray restituita dalla richiesta non implementa l’interfaccia Iterator.

L’ultima istruzione nella nostra funzione invia l’istanza della JsonArrayRequest creata alla RequestQueue di Volley in modo che sia eseguita.

 

Visualizzare la quotazione di BTC

Una volta sviluppato il client, visualizzare la quotazione di una criptovaluta richiede minimo sforzo. Per prima cosa, dobbiamo aggiornare il layout content_main.xml aggiungendo due TextView per ogni criptovaluta che vogliamo visualizzare: una TextView sarà per il nome della valuta e una per la sua quotazione.

Android offre decine di possibilità per fare ciò, utilizzando diversi layout (o combinazioni di layout differenti) per posizionare gli elementi in maniera ottimale: nel nostro caso ci interessa offrire una semplice dimostrazione, per cui opteremo per un semplice TableLayout contenente due TextView per ogni riga (TableRow). Per mostrare la quotazione dei Bitcoin aggiungiamo:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android
="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:context=".MainActivity"
tools:showIn="@layout/activity_main">
 <TableLayout
   android:layout_width="368dp"
   android:layout_height="495dp"
   tools:layout_editor_absoluteX="8dp"
   tools:layout_editor_absoluteY="8dp">
   <TableRow
     android:layout_width="match_parent"
     android:layout_height="match_parent" >
     <TextView
       android:id="@+id/btcLabel"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_marginLeft="10dp"
       android:layout_marginRight="20dp"
       android:text="Bitcoin"
       android:textSize="24sp"
       android:textStyle="bold" />
     <TextView
       android:id="@+id/btcValue"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="0"
       android:textSize="24sp" />
   </TableRow>
 </TableLayout>
</android.support.constraint.ConstraintLayout>

La prima TextView (il cui id è btcLabel) contiene il testo “Bitcoin”, mentre la seconda (id: btcValue) è quella che passeremo al nostro client perché ci inserisca la quotazione del Bitcoin in tempo reale.

Aggiornare la classe principale

Aggiorniamo ora la classe principale dell’applicazione in modo che richiami il client di CoinMarketCap e aggiorni la quotazione dei Bitcoin:

class MainActivity : AppCompatActivity() {
  var queue : RequestQueue? = null
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    queue = Volley.newRequestQueue(this.applicationContext)
    val btcValueTextView = findViewById<View>(R.id.btcValue) as TextView
    queue!!.publishQuote("BTC", btcValueTextView)
  }
}

Ancora una volta, il codice è molto semplice:

  • creiamo e inizializziamo la RequestQueue di Volley;
  • otteniamo il riferimento alla TextView btcLabel tramite la funziona findViewById (ereditata dalla classe base);
  • utilizzando l’extension function sviluppata nella sezione precedente, richiamiamo la CoinMarketCap API passando il simbolo “BTC” e il riferimento alla TextView in cui inserire il valore.

Eseguiamo ora l’applicazione ed il risultato sarà simile a quello mostrato in figura 7.

Figura 7 – L’applicazione mostra la quotazione dei Bitcoin in tempo reale.

Figura 7 – L’applicazione mostra la quotazione dei Bitcoin in tempo reale.

 

A questo punto possiamo completare l’applicazione aggiungendo ulteriori righe al TableLayout della nostra applicazione, una per ogni criptovaluta che vogliamo visualizzare, seguendo la struttura utilizzata per la quotazione dei Bitcoin.

 

Conclusione

Una volta presa dimestichezza con Kotlin, utilizzare il linguaggio in diversi ambiti e per lo sviluppo di applicazioni diverse richiede poco sforzo; in particolare, l’abbondanza di documentazione e il supporto diretto in Android Studio rendono il suo utilizzo per lo sviluppo di applicazioni Android un passo naturale.

Essendo Kotlin completamente compatibile con Java 6, non è necessaria alcuna particolare accortezza nello sviluppo di applicazioni mobili, anche se alcune librerie Java (specialmente le più datate), quando utilizzate in Kotlin, costringono a utilizzare una sintassi meno elegante e “idiomatica”, come abbiamo visto nell’esempio precedente con la libreria org.json.

Per questo motivo è sempre utile cercare librerie Android sviluppate specificamente per Kotlin, che iniziano ad essere molto numerose: il progetto Awesome Kotlin [7] su Github offre una lista in continuo aggiornamento.

 

Riferimenti

[1] Kotlin and Android

https://developer.android.com/kotlin/index.html

 

[2] Android Studio

https://developer.android.com/studio/

 

[3] Documentazione di Android Studio

https://developer.android.com/studio/intro/

 

[4] CoinMarketCap JSON API Documentation

https://coinmarketcap.com/api/

 

[5] Volley: documentazione

https://developer.android.com/training/volley/

 

[6] Volley: progetto su Github

https://github.com/google/volley

 

[7] Awesome Kotlin su Github

https://github.com/mcxiaoke/awesome-kotlin#libraries

 

[8] Mokabyte: articoli su Android

http://www.mokabyte.it/tag/Android/

 

[9] Il codice completo dell’applicazione Cryptodroid

https://github.com/fdiotalevi/cryptodroid

 

Condividi

Pubblicato nel numero
240 giugno 2018
Filippo Diotalevi si occupa di consulenza IT da circa 20 anni. Dopo la laurea in Ingegneria Informatica, ha lavorato in Italia e Germania, e si è stabilito da alcuni anni a Londra dove continua ad essere attivo nella progettazione e sviluppo di applicazioni per la Java Virtual Machine. È autore…
Articoli nella stessa serie
Ti potrebbe interessare anche