How to use GraphQL with Retrofit on Android?

Introduction

GraphQL is a query language for APIs that provides a powerful and flexible way to fetch data. Retrofit is a popular Android library that simplifies network requests. This article will guide you through integrating GraphQL with Retrofit on Android to build efficient and modern APIs.

Setting up the Project

1. Project Setup

• Create a new Android Studio project.
• Add the necessary dependencies to your `build.gradle` (Module: app) file:

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.apollographql.apollo:apollo-android:2.5.6'
implementation 'com.apollographql.apollo:apollo-runtime:2.5.6'

2. Configure GraphQL Server

You’ll need a GraphQL server to host your schema and data. Popular options include:

• Apollo Server (Node.js): https://www.apollographql.com/docs/apollo-server/
• GraphQL Yoga (Node.js): https://www.graphql-yoga.com/
• GraphQL Java: https://www.graphql-java.com/

3. Create a GraphQL Schema

Define the schema for your data. Here’s a simple example:

type Query {
  characters: [Character]
}

type Character {
  id: ID!
  name: String!
  description: String
}

Building the GraphQL API

1. Define GraphQL Queries

Create GraphQL query files using Apollo’s code generation feature. You can use the `apollo-codegen` CLI tool to generate these files.

apollo-codegen generate --endpoint=http://your-graphql-server/graphql --output=src/main/java/com/example/app/graphql --schema=schema.graphql

This will create classes like `CharactersQuery` and `Character` that represent your GraphQL operations and data types.

2. Create Retrofit Interface

Define an interface for your GraphQL API using Retrofit:

public interface GraphQLAPI {

  @GET("graphql")
  Call getCharacters(@Query("query") String query);

}

3. Create Retrofit Instance

Create a Retrofit instance using the Gson converter:

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("http://your-graphql-server/")
        .addConverterFactory(GsonConverterFactory.create())
        .build();

GraphQLAPI graphQLAPI = retrofit.create(GraphQLAPI.class);

Making GraphQL Requests

1. Execute the Query

Execute your GraphQL query using the Retrofit interface:

String query = CharactersQuery.builder()
        .build().toString();

Call call = graphQLAPI.getCharacters(query);
call.enqueue(new Callback() {
  @Override
  public void onResponse(Call call, Response response) {
    if (response.isSuccessful()) {
      List characters = response.body().characters();
      // Process the data
    } else {
      // Handle error
    }
  }

  @Override
  public void onFailure(Call call, Throwable t) {
    // Handle network error
  }
});

Handling Mutations and Subscriptions

1. Mutations

Mutations allow you to modify data on your server. Use a similar approach as with queries:

• Define a GraphQL mutation in your schema.
• Generate a mutation class using `apollo-codegen`.
• Create a Retrofit interface method for the mutation.
• Execute the mutation using Retrofit.

2. Subscriptions

Subscriptions enable real-time updates from your GraphQL server. Apollo provides support for subscriptions. You can use Apollo’s `ApolloClient` and its subscription feature to establish real-time connections.

Example Implementation

1. Activity.java

import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;

import com.example.app.graphql.CharactersQuery;
import com.example.app.graphql.GraphQLAPI;

import java.util.List;

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class MainActivity extends AppCompatActivity {

    private GraphQLAPI graphQLAPI;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView textView = findViewById(R.id.textView);

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://your-graphql-server/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        graphQLAPI = retrofit.create(GraphQLAPI.class);

        String query = CharactersQuery.builder()
                .build().toString();

        Call call = graphQLAPI.getCharacters(query);
        call.enqueue(new Callback() {
            @Override
            public void onResponse(Call call, Response response) {
                if (response.isSuccessful()) {
                    List characters = response.body().characters();
                    StringBuilder stringBuilder = new StringBuilder();
                    for (CharactersQuery.Character character : characters) {
                        stringBuilder.append(character.name()).append("\n");
                    }
                    textView.setText(stringBuilder.toString());
                } else {
                    Log.e("Error", "Error fetching data: " + response.code());
                }
            }

            @Override
            public void onFailure(Call call, Throwable t) {
                Log.e("Error", "Network error: " + t.getMessage());
            }
        });
    }
}

2. activity_main.xml

3. schema.graphql

type Query {
  characters: [Character]
}

type Character {
  id: ID!
  name: String!
  description: String
}

4. Output

Character1
Character2
Character3

Conclusion

Integrating GraphQL with Retrofit on Android provides a powerful and efficient way to build modern APIs. By leveraging GraphQL’s query flexibility and Retrofit’s simplicity, you can create robust and adaptable applications that seamlessly interact with your data sources.