Accedere alle API di Google

In questa lezione sperimenteremo uno dei maggiori vantaggi dei Google Play Services: l'accesso uniforme alle API dei servizi Google. Non sfrutteremo alcuna
funzionalità specifica al momento, semplicemente evidenzieremo le fasi di interazione con un servizio remoto e la loro contestualizzazione nel ciclo di
vita di un'Activity.

La classe che costruiremo fornirà una base per tutte le future applicazioni che interagiranno con i Google Services.

Classi e Interfacce da utilizzare

Le classi e le interfacce che utilizzeremo apparterranno tutte alla libreria dei GooglePlayServices, più precisamente al package com.google.android.gms.common.

La classe principale è GoogleApiClient. La vedremo presente anche nell'Activity come membro privato, e rimarrà il punto di
riferimento, durante l'esecuzione, per la gestione delle connessioni riuscite, mancate e sospese.

Con GoogleApiClient impartiremo comandi di connessione e disconnessione ai Google Play Services mediante i metodi connect() e disconnect(). Gli
esiti di queste operazioni perverranno all'Activity veicolati da due interfacce, entrambe definite internamente alla classe GoogleApiClient:

• ConnectionCallbacks: presenta due metodi, onConnected e onConnectionSuspended. Il primo viene invocato dal sistema come conferma
  dell'avvenuta connessione. Da questo momento in poi si potrà invocare qualunque funzionalità presso il servizio remoto. Al contrario, il secondo,
  onConnectionSuspended, notificherà un'eventuale imprevista disconnessione dal servizio;
• OnConnectionFailedListener: fornisce un solo metodo, onConnectionFailed. Il codice che lo implementa dovrebbe occuparsi di notificare
  all'utente le difficoltà occorse ed intraprendere eventuali operazioni di recupero.

Integrazione con il ciclo di vita

Altro punto importante è la coesistenza delle operazioni da svolgere, con il ciclo di vita dell'Activity. Un'applicazione professionale deve
essere correttamente integrata nel sistema operativo Android, e affinchè ciò sia avvenga è necessario innanzitutto che essa collabori alla corretta gestione delle risorse.
A tal fine, è importante scegliere di utilizzare il codice più appropriato da inserire nei metodi del ciclo di vita.

Visto che vogliamo realizzare connessioni ai servizi Google da una classe che rappresenta l'interfaccia, è importante che la connessione e la disconnessione avvengano,
rispettivamente, quando l'utente inizia ad utilizzare l'Activity e quando smette di farlo.

A tal proposito, le "coppie" di metodi del ciclo di vita utilizzate di solito per individuare questo lasso di tempo sono onResume-onPause (fase di interazione viva
tra utente e UI) e onStart-onStop (fase di visibilità dell'interfaccia).

Nel nostro esempio utilizzeremo quest'ultima coppia di metodi: in onStart richiederemo la connessione, in onStop la disconnessione.

Google Play Services a disposizione

Affinchè si possa interagire con le API di Google è necessario che i Google Play Services siano disponibili.
Abbiamo già detto come realizzare questa condizione su dispositivi reali Android di versione 2.3 o superiore, che includano il Google Play Store.

Anche l'emulatore può essere utilizzato a tale scopo, ma è importante che esegua una piattaforma Google APIs basata su Android 4.2.2 o superiore.

La figura seguente, a titolo di esempio, mostra uno scorcio dell'Android SDK Manager in cui viene evidenziata la presenza delle immagini di sistema Google
APIs, costruite sia su architettura ARM che Intel e riferite, in entrambi i casi, ad Android versione 4.4.2.

L'esempio

Illustrati i concetti che sono alla base dell'esempio che segue, strutturiamo l'Activity affinchè sappia gestire in maniera completa e autonoma il flusso di
connessione ai Google Play Services.

public class MainActivity extends Activity implements OnConnectionFailedListener, ConnectionCallbacks
{
    private static final int REQUEST_RESOLVE_ERROR = 0;
    private GoogleApiClient client;
    private boolean resolvingError;
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        client = new GoogleApiClient.Builder(this)
                .addApi(LocationServices.API) // qui si aggiungeranno le API richieste
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();
    }
    @Override
    protected void onStart() {
        super.onStart();
        if (!resolvingError)
        {
            client.connect();
        }
    }
    @Override
    protected void onStop()
    {
        client.disconnect();
        super.onStop();
    }
    @Override
    public void onConnectionFailed(ConnectionResult result)
    {
        if (resolvingError)
            return;
        if (result.hasResolution()) {
            try {
                resolvingError = true;
                result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
            } catch (SendIntentException e)  {
                 client.connect();
            }
        } else {
            GooglePlayServicesUtil.getErrorDialog(result.getErrorCode(),this, REQUEST_RESOLVE_ERROR).show();
            resolvingError = true;
        }
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_RESOLVE_ERROR) {
            resolvingError = false;
            if (resultCode == RESULT_OK) {
                if (!client.isConnecting() &&
                        !client.isConnected()) {
                    client.connect();
                }
            }
        }
    }
    @Override
    public void onConnected(Bundle arg0)
    {
       //Connessione riuscita: qui è possibile iniziare ad usare le API
    }
    @Override
    public void onConnectionSuspended(int arg0)
    {
       //Connessione sospesa
    }
}

In fase di creazione (metodo onCreate), oltre alla necessaria impostazione del layout che qui assumiamo collocato nel file
activity_main.xml, istanziamo l'oggetto GoogleApiClient. La sua costruzione avverrà tramite Builder, quindi penseremo prima a configurarlo ed infine ad
invocare il metodo build per ottenerne un riferimento.

client = new GoogleApiClient.Builder(this)
                .addApi(LocationServices.API)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();

Nella configurazione abbiamo usato i tre seguenti metodi:

• addApi: per comunicare quale set di API Google vogliamo utilizzare. L'identificazione delle API avverrà tramite un'apposita costante. In
  questo caso, ad esempio, ci siamo riferiti alle API dei LocationServices, che tratteremo più avanti in questa stessa guida; ma in generale, il programmatore dovrà
  sostituire questo valore con quello relativo alle API di suo interesse;
• addConnectionCallbacks: definisce il listener per le invocazioni ai metodi di callback mediante i quali viene notificato il successo o
  la sospensione della connessione ai Google Play Services;
• addOnConnectionFailedListener: imposta il listener per la notifica del fallimento alla connessione.

Nell'esempio entrambi i listener, assegnati a GoogleApiClient, sono interpretati dall'Activity stessa che implementa le interfacce
OnConnectionFailedListener e ConnectionCallbacks.

Le richieste di connessione e disconnessione, come già anticipato, verranno effettuate, rispettivamente, all'interno dei metodi onStart e onStop.

La connessione viene richiesta invocando connect(). Tale metodo restituisce subito il controllo al chiamante, ma la connessione si
considera correttamente stabilita solo al momento dell'invocazione del metodo di callback onConnected. Quest'ultimo rappresenta il punto di inizio della
vera e propria interazione con le API dei servizi Google.

In caso di fallimento della connessione viene invocato il metodo onConnectionFailed. Questo è il punto del codice in cui iniziano i
tentativi di correzione dell'errore.
Nell'esempio precedente, si vede che all'interno di tale metodo è presente un blocco if che verifica se l'errore è risolvibile (metodo
hasResolution) mediante operazioni autorizzate dall'utente:

if (result.hasResolution()) {
            try {
                resolvingError = true;
                result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
            } catch (SendIntentException e) {
                client.connect();
            }
        } else {
            GooglePlayServicesUtil.getErrorDialog(result.getErrorCode(),this, REQUEST_RESOLVE_ERROR).show();
            resolvingError = true;
        }

Se hasResolution restituisce il valore true, sarà invocato il metodo startResolutionForResult, il quale inoltrerà appositi Intent per richiedere un
intervento manuale dell'utente per la risoluzione della situazione di errore. In caso contrario, verrà richiesta l'apertura di una finestra di dialogo appositamente inclusa nella libreria dei Google Play Services (metodo getErrorDialog della classe GooglePlayServicesUtil) che comunicherà all'utente il perchè è
impossibile attivare le API di Google.