Client Android

Il progetto Apollo è una ricca libreria di client per servizi
GraphQL che offre, tra l'altro, un'ottima integrazione con app Android. La sua peculiarità è quella di basarsi sulla generazione di codice a partire da uno schema in JSON e da uno o più file con estensione .graphql. Ciò, di fatto, crea in automatico delle classi Java da integrare nella propria app. I passi da seguire per fare tutto ciò sono:

• integrazione di Apollo nel progetto Android Studio;
• generazione dello schema GraphQL per la predisposizione della code generation;
• scrittura del codice Java sfruttando le nuove classi create in automatico nonchè quelle già presenti nella
  libreria.

Integrazione di Apollo

L'integrazione della libreria avviene mediante Gradle, mettendo mano sia al file build.gradle relativo al progetto, sia a quello del modulo applicativo:

• nel build.gradle del progetto, apportiamo i seguenti innesti:
  

  buildscript {
    repositories {
      jcenter()
    }
    dependencies {
      classpath 'com.apollographql.apollo:apollo-gradle-plugin:0.3.2'
    }
  }

  
  Così facendo abbiamo richiesto il plugin per Gradle di Apollo, aggiungendo una nuova dipendenza nel blocco buildscript;

• nel build.gradle del modulo applicativo, si deve aggiungere il riferimento al nuovo plugin (nelle prime righe
  del file) e le dipendenze necessarie per poter sfruttare le classi della libreria:
  

  apply plugin: 'com.apollographql.android'
  ...
  ...
  dependencies {
    ...
    ...
    implementation 'com.apollographql.apollo:apollo-runtime:0.3.2'
    implementation 'com.apollographql.apollo:apollo-android-support:0.3.2'
  }

Schema GraphQL

Tutto quello che creeremo in questo paragrafo contribuirà alla generazione automatica del codice. Lo collocheremo
in una sottocartella di src/main, che chiameremo graphql, di pari livello quindi della cartella src/main/java.
Lo schema GraphQL può essere reperito dal servizio stesso (noi supporremo di accedere anche in questa lezione a quello creato nel corso della guida) mediante il client di Apollo, reperibile su GitHub, ed installabile
sfruttando npm.
Con il servizio target running, possiamo inoltrare il seguente comando (modificando opportunamente l'indirizzo) ed
ottenere un file schema.json, frutto di un'attività di introspezione:

apollo schema:download --endpoint=http://localhost:8888/proverbi schema.json

Aggiungeremo inoltre file .graphql dedicati alle singole operazioni di query e mutation che vogliamo svolgere dall'app
Android. Ad esempio, quello relativo alla funzionalità di richiesta di un proverbio casuale potrebbe essere costituito
dal file ProverbioRandom.graphql, contenente:

query ProverbioRandom{
  	proverbioRandom
}

A questo punto, vale la pena ricordare due concetti: il nome che daremo a tale file diverrà il nome della classe generata
in automatico e - aspetto già menzionato - i file .graphql e lo schema.json vanno posizionati nella medesima cartella, che nel
nostro esempio è src/main/graphql. Una volta eseguito il build del progetto, le nuove classi Java saranno generate e
le si potrà coinvolgere nella programmazione.

Il client Apollo

Per collegarci al servizio GraphQL abbiamo bisogno di definire un client Apollo nel seguente modo:

public class MainActivity extends AppCompatActivity {
    private ApolloClient apolloClient;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        ...
        OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
        apolloClient = ApolloClient.builder()
                .serverUrl("http://server_servizio:8888/proverbi")
                .okHttpClient(okHttpClient)
                .build();
		...
		...

Si noti che per la predisposizione dello stack di rete ci si affida a OkHttpClient e
con il metodo serverUrl forniamo l'indirizzo da contattare completo di porta TCP e percorso GraphQL.

Invio di richieste

Per eseguire una richiesta GraphQL, dovremo utilizzare il codice generato in automatico da Apollo. Nel
nostro caso richiederemo un proverbio casuale nel seguente modo:

ProverbioRandom pr=ProverbioRandom.builder().build();
apolloClient.query(pr).enqueue(new ApolloCall.Callback<ProverbioRandom.Data>() {
	@Override
	public void onResponse(@Nonnull Response<ProverbioRandom.Data> response) {
		/*
		 *    codice da svolgere in caso di successo
		 */
	}
	@Override
	public void onFailure(@Nonnull ApolloException e) {
		/*
		 *    codice da svolgere in caso di errore
		 */
	}
});

La classe ProverbioRandom è stata creata in automatico a partire dal file .graphql. Inoltriamo una query in modalità
asincrona tramite il metodo enqueue, che richiederà come argomento un oggetto in grado di fare da listener sia in caso
di successo (onResponse) sia in caso di errore (onFailure). Se tutto sarà svolto correttamente, si
avrà un oggetto di tipo Response<ProverbioRandom.Data> dal quale potremo estrapolare i risultati ritrovando metodi
che ricordano proprio le proprietà del nostro servizio GraphQL.