Google Plus: accesso e gestione

Accesso a Google Plus

Per interagire con Google Plus da un'Activity, dovremo integrare un oggetto GoogleApiClient che curerà tutta la fase di dialogo con i Google Play Services. Lo includeremo come membro interno della classe:

public class MainActivity extends Activity implements GoogleApiClient.OnConnectionFailedListener, GoogleApiClient.ConnectionCallbacks
{
    private GoogleApiClient mGoogleApiClient;
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .addApi(Plus.API)
                .addScope(Plus.SCOPE_PLUS_LOGIN)
                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .build();
      ...
      ...
    }
    ...
    ...
}

All'interno del metodo onCreate inizializziamo l'oggetto GoogleApiClient. Il metodo addApi questa volta riceve come parametro in input il
valore Plus.API ad indicare l'intenzione di sfruttare le funzionalità del social network. L'approccio, come si può vedere, è lo stesso visto nel caso di Drive o dei LocationServices. Ciò dimostra come GoogleApiClient uniformi alla perfezione le problematiche di accesso a tutti i servizi Google.

Il metodo addScope riceve il livello di autorizzazione che vogliamo attribuire all'app. Le possibilità sono due:

• SCOPE_PLUS_LOGIN (usato nell'esempio) è il livello normale. Permette di accedere alle informazioni base del profilo e alla lista di persone incluse
  nelle cerchie dell'utente;
• SCOPE_PLUS_PROFILE è il livello più avanzato, che consente l'accesso ad informazioni di profilo più dettagliate.

La connessione e la disconnessione vengono eseguite in sintonia con il ciclo di vita dell'Activity, quindi nei metodi onStart (connessione) ed onStop (disconnessione):

@Override
    protected void onStart() {
        super.onStart();
        if (!resolvingError)
        {
            mGoogleApiClient.connect();
        }
    }
    @Override
    protected void onStop()
    {
       if (mGoogleApiClient.isConnected())
            mGoogleApiClient.disconnect();
        super.onStop();
    }

Come già discusso nel capitolo di questa guida relativo a GoogleApiClient, i messaggi di successo o fallimento in fase di connessione verranno notificati
all'Activity mediante i metodi esposti dalle interfacce che essa implementa, OnConnectionFailedListener e ConnectionCallbacks:

• onConnected(Bundle arg0): in questo metodo può essere avviato il codice che sfrutta il servizio. Nel caso di Plus, si potrà iniziare a leggere ed utilizzare le informazioni sul profilo utente;
• onConnectionSuspended(int arg0): questo metodo ospiterà codice di reazione ad un'imprevista interruzione della connessione. Tipicamente includerà il codice per un tentativo di riconnessione;
• onConnectionFailed(ConnectionResult result): se viene invocato questo metodo significa che non è stato possibile ottenere una connessione. In questo caso è necessario intraprendere operazioni di recupero, selezionate in base al codice di errore espresso all'interno del parametro ConnectionResult.

People: recuperare informazioni sull'utente

Dopo che il metodo onConnected è stato invocato, forti della certezza che la connessione con il servizio Google è attiva, possiamo, ad esempio, recuperare i dati dell'account utilizzato per la connessione.

if (Plus.PeopleApi.getCurrentPerson(mGoogleApiClient) != null)
{
    Person currentPerson = Plus.PeopleApi.getCurrentPerson(mGoogleApiClient);
    String personName = currentPerson.getDisplayName();
    String accountName = Plus.AccountApi.getAccountName(mGoogleApiClient);
    ...
    ...
}

Questo breve stralcio di codice ha lo scopo di inserire in due stringhe il nome dell'utente visualizzato nel profilo ed il suo account name, che solitamente corrisponde ad un indirizzo di posta elettronica GMail.

Al di là dell'utilizzo pratico, queste righe di codice Java dimostrano come la classe Plus metta a disposizione tutte le funzionalità delle API. In questo caso,
avendo bisogno dei dati di una persona, utilizziamo le PeopleApi. Si noti che in ogni riga viene passato come parametro l'oggetto GoogleApiClient che
offre la connessione attualmente disponibile al servizio.

La classe Person coinvolta appartiene al package com.google.android.gms.plus.model.people che contiene gli strumenti del modello informativo relativo alle persone del social network.

Quando il programmatore avrà bisogno di interagire con qualche funzionalità, la metodologia da adottare sarà simile alla descrizione seguente:

• si individua all'interno di Plus il sottoinsieme delle funzionalità;
• si passa un riferimento ad un oggetto GoogleApiClient con una connessione attiva. In termini pratici, ciò significa che il metodo onConnected deve essere già stato richiamato;
• si invocano i metodi necessari e si prelevano i dati dagli oggetti restituiti, come si è fatto in questo caso con Person.

Post interattivi

Una funzionalità interessante da includere nella propria app sono i post interattivi. Sono un modo per condividere informazioni con gli appartenenti alle
proprie cerchie, consentendo al tempo stesso di invitarli ad interagire, ad esempio visitando un link.

Su Android, per sfruttare i post interattivi, è necessario configurare un apposito Intent prodotto mediante il Builder incluso nella classe PlusShare. Vediamo un esempio:

Intent intent = new PlusShare.Builder(this)
                .setType("text/plain")
                .setText("Leggiamo gli ultimi articoli su HTML.it")
                .setContentUrl(Uri.parse("http://www.html.it"))
                .getIntent();

Questo Intent prepara la bozza di un post in formato plain text contenente la frase “Leggiamo gli ultimi articoli su HTML.it” ed il link http://www.html.it.

Successivamente, l'Intent deve essere inoltrato al sistema con i consueti metodi del Context, startActivity o startActivityForResult.

Sarà quindi avviata una sorta di creazione guidata del post, nel corso della quale l'utente potrà specificarne i contenuti e, ovviamente, la visibilità nelle cerchie. Il risultato sarà disponibile immediatamente nella propria pagina Google+. Vi troveremo infatti un nuovo post che apparirà simile a quello mostrato nella figura seguente.

Accesso con il pulsante Sign-in

Tra i vari strumenti offerti dai Google Play Services c'è anche un pulsante di Sign-In già pronto, come quello visibile in figura:

È un controllo personalizzato che può essere incluso in qualsiasi layout con il seguente nodo XML:

<com.google.android.gms.common.SignInButton
        android:id="@+id/btn_sign_in"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

Con tale pulsante si fornirà all'utente una modalità comoda, visivamente riconoscibile e sicura per la connessione a Google Plus, che sarà successivamente necessaria per svolgere qualsiasi altra attività.

Al pulsante è possibile aggiungere un listener dell'evento click con cui si potranno gestire eventuali situazioni di errore.

Conclusioni

Poiché Google+ è un sistema soggetto ad autenticazione, il primo aspetto da curare è la connessione tramite GoogleApiClient, senza tralasciare la gestione degli errori. Successivamente si potrà iniziare a fare uso di post interattivi, ricerche di persone e attività varie.