[MUSICA]
Una delle caratteristiche distintive dei sistemi mobile moderni è che essi possono
tenerci collegati in rete senza tenerci legati a una singola locazione.
In questa lezione, esploreremo il software e
le pratiche di programmazione che servono per collegare le applicazioni alla rete.
Quindi inizierò questa lezione discutendo del networking in generale.
Tale discussione si concentrerà sul collegamento delle app a Internet
usando l'HyperText Transfer Protocol
o HTTP, precisamente tramite richieste HTTP GET.
Dopo di che, vi presenterò diverse classi che Android offre per supportare questo
tipo di networking e infine, discuterò di come le applicazioni possono
elaborare i dati ricevuti in risposta a queste richieste HTTP GET.
In particolare, parlerò di due popolari linguaggi di formattazione dei dati.
Uno, il JavaScript Object Notation Language,
o JSON e due, l'Extensible Markup Language, o XML.
E parlerò di come si analizzano, o si capiscono,
queste risposte HTTP quando sono formattate in uno di questi linguaggi.
Dunque, i primi dispositivi palmari ci hanno dato la mobilità.
Ci si poteva spostare da un luogo all'altro, ed eseguire comunque computazioni utili.
Tuttavia, le loro capacità di networking erano primitive per gli standard odierni.
Ora, andando avanti, i dispositivi di oggi combinano potenti processori con
veloci connessioni di rete via WiFi e reti cellulari.
Le applicazioni portatili quindi vorranno spesso far uso
di queste funzionalità di rete per accedere a dati e servizi e fornirne.
Per aiutarvi a farlo, Android include una varietà di classi di supporto al netwoking
tra cui le classi Socket e URL, nei package java.net,
le classi HttpRequest e HttpResponse, nei package org.apache.
E le classi URI, AndroidHttpClient, e AudioStream, nei package android.net.
In questa lezione guarderemo molte di queste classi,
usando ciascuna di esse per implementare la stessa applicazione di esempio.
Quest'applicazione interagisce con un servizio internet per ottenere informazioni
sui terremoti che si sono verificati in una particolare regione geografica.
E come vedrete, quei dati vengono restituiti in vari formati.
Inizialmente ci limiteremo a visualizzare il testo così come viene scaricato.
Più avanti nella lezione, vi mostrerò come processare
quei dati per estrarre solo le informazioni che volete.
Oh, e un'altra cosa.
Come si vedrà tra un momento, poiché questi dati includono informazioni geografiche,
sarebbero più adatti ad essere mostrati su una mappa, piuttosto che come testo.
Ora, non lo faremo in questa lezione, ma ricordatelo,
perché ci ritorneremo quando arriveremo alla lezione su mappe e posizione.
Per far funzionare quest'applicazione, il codice deve creare una richiesta http,
inviarla a un server, recuperare i risultati, e quindi visualizzarli.
Android fornisce molte classi per aiutare con questo.
Tre di cui parleremo ora sono la classe Socket,
la classe HttpUrlConnection e la classe AndroidHttpClient.
Ora lancerò l'applicazione NetworkingSockets.
Come potete vedere,
quest'applicazione all'inizio visualizza un solo pulsante etichettato "Load Data" (Carica i Dati).
Quando premo il pulsante, l'applicazione emette una richiesta HTTP GET
a un server esterno, e quel server risponderà con del complesso
che contiene i dati dei terremoti richiesti.
Ok, quindi ora premo il pulsante "Load Data"
e si possono vedere i dati richiesti.
Diamo un'occhiata al codice sorgente per vedere cosa fa per ottenere i dati.
Ora qui ho aperto l'applicazione nell'IDE.
Ora aprirò l'Activity principale di
questa applicazione, e qui sto mostrando il listener del tasto "Load Data".
Quando si preme questo pulsante, l'applicazione crea, e
quindi esegue, un AsyncTask chiamato HttpGetTask.
Diamo un'occhiata a quella classe.
La classe HttpGetTask dichiara in primo luogo alcune variabili, che
vengono utilizzate nella creazione di una richiesta HTTP GET.
Quando viene chiamato il metodo execute, sul HttpGetTask,
viene chiamato il metodo doInBackground.
E questo metodo inizia con la creazione di un nuovo Socket,che verrà connesso
al computer host, api.geonames.org sulla porta HTTP standard, porta 80.
Successivamente, il codice ottiene l'OutputStream del Socket,
e quindi scrive l'HTTPGETCOMMAND, e questa stringa sarà inviata al computer host,
che la interpreta come una HTTPGetRequest,
e quindi risponde inviando i dati di risposta appropriati.
Quindi questo codice continua ottenendo l'InputStream del Socket e
passandolo a un metodo chiamato readStream.
Il metodo readStream infine legge i dati di risposta dall'InputStream del Socket.
e quindi restituisce la risposta come una singola stringa.
E questa stringa viene passata al metodo onPostExecute che
viene eseguito sul thread principale e che visualizza la risposta nella TextView.
Torniamo all'applicazione.
Si noterà che il testo di risposta include non solo i dati dei terremoti, ma
anche gli header della risposta HTTP.
Ora, di norma, non vorrei mostrare questo testo qui.
Voglio solamente mostrare i dati dei terremoti.
Quindi avrei dovuto analizzare la risposta ed
estrarre solo i dati che volevo.
Inoltre, potreste aver notato che non ho scritto alcun
codice per la gestione di errori necessario per rendere quest'applicazione robusta.
E questi punti catturano abbastanza bene gli svantaggi nell'usare i Socket.
Il livello è molto basso,
puoi scrivere qualsiasi cosa tu voglia sul socket,
ma in cambio hai bisogno di gestire tutti i dettagli del fare le richieste HTTP,
tutta la gestione degli errori, e tutto il processing delle risposte HTTP.
La prossima implementazione che vedremo usa la classe HttpUrlConnection.
Questa classe fornisce un'interfaccia di più alto livello, che gestisce più
dettagli del networking rispetto alla classe Socket, ma come vedremo tra breve,
ha anche una API meno flessibile della nostra ultima opzione,
la classe AndroidHttpClient.
Detto questo, voglio anche sottolineare che il team Android non sta più
lavorando attivamente sulla classe AndroidHttpClient, e
si sta concentrando sul miglioramento della classe che vedremo ora.
Quindi guardiamo l'applicazione di esempio, implementata questa volta
con la classe HttpUrlConnection.
Ora lancio l'applicazione NetworkingURL.
Come prima, quest'applicazione mostra inizialmente un singolo pulsante
un singolo pulsante etichettato "Load Data" e come prima, quando premo quel pulsante
l'applicazione emette una richiesta HTTP GET
a un server esterno,
e tale server risponderà con del testo complesso,
contenente i dati richiesti sui terremoti.
Ok,
quindi ora premo il pulsante "Load Data".
Si possono vedere i dati richiesti apparire in una TextView.
Si noti, tuttavia, che stavolta gli header della risposta HTTP sono stati rimossi.
Diamo un'occhiata al codice sorgente e vediamo come funziona.
Ora, qui ho l'applicazione aperta nell'IDE.
Ora apro la MainActivity di
di quest'applicazione, e qui mostro il listener del pulsante "Load Data".
Come prima, quando si preme questo tasto, l'applicazione crea e
quindi esegue un AsyncTask chiamato HttpGetTask.
Guardiamo quella classe.
Quando il metodo execute viene chiamato su HttpGetTask,
viene invocato il metodo doInBackground.
Tale metodo inizia creando un nuovo oggetto URL e
passando una stringa URL per il servizio desiderato come parametro.
Il codice chiama quindi il metodo openConnection sull'oggetto URL,
che restituisce una HttpUrlConnection.
Quest'oggetto viene poi memorizzato in una variabile chiamata httpURLConnection.
Il codice prosegue ottenendo l'InputStream
della HttpUrlConnection e passandola al metodo readStream.
E come prima, il metodo readStream legge i dati di risposta dal flusso
di input del Socket, poi restituisce la risposta come una singola stringa.
Questa volta, però, la HttpUrlConnection rimuove gli header
della risposta HTTP e gestisce il controllo degli errori per te.
Ora questa stringa viene quindi passata al metodo onPostExecute,
che mostra la risposta in una TextView.
La terza classe è AndroidHttpClient.
Questa classe è un'implementazione del DefaultHttpClient del progetto Apache
e permette una grande personalizzazione.
In particolare, la classe divide la transazione HTTP in un
oggetto richiesta e in un oggetto risposta.
Quindi si possono creare sottoclassi che personalizzano la gestione delle richieste
e delle loro risposte.
Ora conoscete già l'aspetto dell'applicazione, quindi
quindi saltiamo direttamente al codice ed esaminiamo l'implementazione.
Ora, qui ho aperto l'applicazione
NetworkingAndroidHttpClient nell'IDE.
Ora apro la MainActivity di questa applicazione, e andiamo direttamente
alla classe HttpGetTask. Tale classe inizia creando un nuovo
oggetto AndroidHttpClient, chiamando il metodo newInstance della classe.
Quando viene chiamato il metodo doInBackground, il codice crea
un oggetto HttpGet, passando la stringa URL per quella richiesta.
Quindi, crea un oggetto ResponseHandler.
Quest'oggetto è responsabile della gestione della risposta
alla richiesta HttpGet: in questo caso, il ResponseHandler è del tipo
BasicResponseHandler, che restituirà il corpo della risposta.
Vedremo un ResponseHandler più complesso più avanti in questa lezione.
E, infine, la richiesta e il ResponseHandler vengono passati al metodo execute,
che invia la richiesta e ottiene la risposta, passandola attraverso il
ResponseHandler, e il risultato di tutto questo viene poi passato ad onPostExecute,
che mostra la risposta in un campo di testo.