This article was originally posted here

I wish someone had written an article like this when I started my learning journey with RxJava in 2017. I wish there had been a perfect book or some kind of an online school which taught me how to get started with Rx the right way.

There has been so much hype right now around RxJava and Reactive Programming in general. Everyone seems to promote it, but no one seems to have an idea about how a novice programmer who is just starting out with RxJava should go about this journey.

All this has a reason! RxJava has a steep learning curve and there is no one way to master it. Some prefer the docs (which are excellent, by the way), some prefer books about RxJava with some examples, while some crazy ones (including me facepalm) commit the mistake of diving right into the code after watching a YouTube video of a talk by Kaushik Gopal on how to get started with RxJava and start refactoring their code.

The last method is absolutely dangerous, and instead of solving your problems with Rx, you’ll just end up creating new ones. So, I suggest that you follow the roadmap given below to get started with RxJava.

While this is by no means the only way to go about it, after having experience of almost 1.5 years with RxJava (and still learning), I wish someone had told me these things when I was beginning my journey. If you follow the given roadmap religiously, I can ensure you that you’ll have a strong foundation in RxJava which you can then build upon to unleash its full potential.

I have divided the entire roadmap into four phases:

• The Discovery: Say hello to the world of Reactive Programming.
• The disillusionment: World ain’t all sunshine and rainbows.
• Eureka!
• Sky’s the limit

So, let’ get straight into it.

Phase 1

The Discovery: Say hello to the world of Reactive Programming

I could have also titled this phase “The Motivation”, because this is the very initial phase where you’ve heard about RxJava from a friend of yours or someone on LinkedIn posted about it or you just happen to stumble upon a piece of code with Observables flying around all over the place.

Whatever the case, when you first go about looking at a piece of RxJava routine (even the simplest one), you might be intimidated by all the methods being called one after the other in a single chain. But you’ll notice that the code looks neater than any other you’ve ever seen. And it accomplishes unimaginably complex tasks with simple method chains while you’ve been forming AsynTask and thinking about multiple Retrofit/Volley calls in your head.

Tasks such as making multiple API calls one after the other, making API calls and saving into a database and returning a success or a failure etc… are being accomplished within 20–25 lines of code. You’ll be intimidated but at the same time inclined to find out what this tool is, and how you can also get started writing such neat code.

So, in order to get you started here is a list of things I need you to do in this phase:

I suggest that you watch this talk by Kaushik Gopal at least twice (it took me 4 replays to get a hold of it. I had the talk downloaded on my computer) to completeness. According to me, it’s the gold standard of anyone looking to dive into reactive programming.

Kaushik Gopal beautifully explains the nuances of RxJava and provides real-world examples, with a hint of abstraction on the absolute technicalities, easily understandable by any beginner. He divides any RxJava routine into 4 basic constructs (even my article on RxJava: Understanding RxJava Basics is inspired by his talk).

Surely on the first attempt, you won’t be able to get a hold of what exactly is an observable and how the observer pattern works. That’s why I suggest that you watch it at least twice.

Here’s what you should be clear about from this talk (at least):

• What is an Observable?
• What is a Subscriber?
• How do Observables and Subscribers work together?
• What is an operator (not the specific functionality, but what an operator does)?

Replay it as many times as you want, but you should be absolutely clear about the above 4 questions after you’re done. You can also refer to the text available online along with this video. Don’t move forward unless and until you understand the above nuances clearly else, you’ll end up being more confused than before.

Once you’re done, go ahead and watch this talk by Christina Lee:

Watch this talk once, but I want you to focus especially from 28:20–32:50. During these 4 minutes, she gives an absolutely beautiful explanation on what the two most used operators in any RxJava routine, observeOn() and subscribeOn() do and how they’re used together, using an example.

These operators are together included as one of the main constructs, in the 4 constructs of RxJava explained by Kaushik Gopal. And believe me, they are really important in your journey with reactive programming and RxJava in general.

Create a project in Android Studio (if you are an android developer) or any IDE of your choice and run the exact same code that Christina provides. Once you set that up, you can play around by changing the order of observeOn and subscribeOn and see how they behave. Try adding multiples of these and see who dominates and what’s the output. You’ll get a good grasp on the functions of these operators once you do this exercise.

Don’ts: YouTube would recommend multiple talks on RxJava by Jake Wharton, but I highly suggest that you ignore those for the time being. Those talks can get really intimidating after some time and you’ll most likely drop off somewhere in between and maybe even give up on RxJava altogether. So, stay away from them for the time being.

Phase 2

The Disillusionment: the world ain’t all sunshine and rainbows

This phase could also be named “The Struggle”. This is the phase where you need to start getting your hands dirty by writing some actual RxJava code.

I’d suggest that you start by making some API calls with RxJava and I’ve already published a post for this exact same purpose: Networking with Retrofit-RxJava-MVP Architecture

Understand what’s going on here. You’ve probably already made some API calls in your Android Development journey using Retrofit/Volley. But this article will explain how to put them together properly in order to get separation of concerns and make your code more modular and ultimately easy to understand and scale at some later stage.

It also includes the use of MVP Pattern which is really simple but you can omit that if it gets too technical. Just focus on creating the Adapter, the API service interface, and the UserTask. Rest assured that it’s all just simple Android code. You can invoke UserTask from anywhere and get the result in a callback.

Once you’ve done this, you’ll get a gist of what it’s like to work with RxJava.

Next, you should develop an app yourselves which involves networking. You could you the fakeJson web service/make a twitter client/consume a rotten tomatoes API, or anything which involves networking. You’ll find out how different operators such as Map and FlatMap come in handy while transforming your observables into something of your requirement.

As you do that, you’ll start feeling more confident with RxJava routines and observe that most of the code is the same across these applications. Of course, there will be different operators used and a difference in your models. But the overall gist is somewhat similar.

Now you’re ready for Phase 3 and getting to that Eureka moment ?

Phase 3

Eureka!

This is the phase where you’ll get out of your comfort zone and start exploring what RxJava can do for your Android app rather than just networking. This is where you’ll learn about the art of state management with RxJava and how you can Rxify almost everything in your code. In this section, I’ll push you to start State Management with RxJava.

This is also the point where you are ready to watch all of Jake Wharton’s talks on RxJava. Actually, this will be your task in this phase, but first, let’s understand what is state management.

What is state management?

Let’s think of an example. Say, you have a simple login/signup application where you ask the user for their username and password and when they click a button, you sign them in/direct to a signup page.

Now as soon as the user enters his details and clicks the submit button, a loader is shown while the app sends the data to a backend service and waits for the response. We can say that currently, our app is in an “inProgress” state.

As the result is returned, the app reverts back to the “Idle” state.

To elaborate further, let’s talk about the submit button. When the text fields are empty, i.e. the user hasn’t entered anything yet, then the button should be disabled. So, “disabled” becomes a state of the button. When the user has entered the info and the fields are validated, the button should be in “enabled” state.

So, you see, everything you see on the screen, exists in a particular state. Right from that button, to the progress bar, everything is in a particular state.

All’s good but what to do now?

Here’s what I want you to do.

Start by watching this talk about state management by Jake Wharton:

This talk is for advanced developers and I had to watch it at least 10 times to wrap my head around what was going on. But watching a video alone won’t make you a pro at RxJava. You’ll need to state manage your applications using RxJava.

To practice with state management, I’d suggest picking up any simple idea/one single screen and start state managing it with RxJava. For example, if your app includes a login/signup screen, you can perform its state management using RxJava as mentioned above.

Here are a couple of ideas for you:

• Develop a login/registration app. After the user logs in, consume the Rotten Tomatoes API. Allow a search functionality so the user can search for movies according to his liking. In all of this, the progress bars and the animations must be states which would be managed within RxJava streams. Rx would also be used for making API calls.
• Check out this repository by Kaushik Gopal which includes an example of form validation with RxJava. Clone it, and try and understand the code. Once you’re comfortable, start implementing it yourself. Think of what all states you could add to it to increase the complexity. For example, a checkbox to reveal the password.

You’ll definitely get your Eureka moment in this phase where you realize the vast potential of RxJava and how you can possibly do anything with it and make your code neater.

Phase 4

Sky’s the limit

I’ll leave this section blank for you. Now it’s up to you to tell me about all the creative ways you’ve used RxJava in your code and how RxJava has made your life easier than before. One thing I’ve noticed as I’ve started writing these blogs is that these have definitely helped me become a better Android developer as I’m accountable for everything I post.

In this post, I’ve shared everything that worked for me and what I think will work for you. If you have any suggestions, let me know in the comments section below. I urge you to share your learnings with everyone and help each other grow and become better engineers.

Like what you read? Don’t forget to share this post on Facebook, Whatsapp, and LinkedIn.

You can follow me on LinkedIn, Quora, Twitter, and Instagram where I answer questions related to Mobile Development, especially Android and Flutter.

If you want to stay updated with all the latest articles, subscribe to the weekly newsletter by entering your email address in the form on the top right section of this page.

This article was originally posted here

In this Android App development tutorial, I’ll be demonstrating how you can setup Retrofit and RxJava for networking in your android application along with MVP Architecture.

We’ll be developing a very barebones application which will display some data in recyclerview. The data will be obtained from a fake JSON API hosted on https://jsonplaceholder.typicode.com. The application will display data in three columns namely ID, Title and Body.

Here are the prerequisites to this tutorial:

• How to Implement MVP Architecture in Android
• Understanding RxJava Basics

Once you go through the above two, you are ready to move forward with this article. I’ve divided this into 4 phases:

• Setting up the project and building layouts.
• Setting up MVP Architecture.
• Creating Model class for data and adapter for RecyclerView.
• Setting up Networking with Retrofit and RxJava.

So, let’s get started!

Note: Some online schools such as Udemy and Lynda also have good tutorials on RxJava

Phase 1: Setting up the project and building layouts.

Create a new project

Create a new project in android studio. Go to File -> New Project and select “Empty Activity”. Then click Finish.

Adding a Recyclerview

To add a recyclerview to your project, open app level build.gradle file and add the following dependency at the bottom:

implementation 'com.android.support:design:28.0.0'

Note: You can also add recyclerview directly instead of the entire design library, but most of you might already have it included so I’m including the design library in this example. You can include just the recyclerview as well.

Now head over to your main layout file, in my case activity_main.xml and add a recyclerview inside the root layout:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".UserActivity">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/recyclerview"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

Building Recyclerview Item

Now let’s start building the RecyclerView rows. Here we are only concerned about the architecture of our Android application and how Retrofit, RxJava and MVP Architecture can work in tandem, so don’t complain about the look of the UI :P. You can definitely go ahead and beautify it.

We’ll be creating a really simple three column layout. The first column will display the ID of the item, the second column will display the Title, and finally, the third column will display the body/description.

Go to res->layout and right click on the layout folder. Create a new “Layout Resource File”. Name it whatever you want, in my case I’ll name it recycler_item.

To create a three-column layout, add a LinearLayout as the root. Then add three textviews and set their width to 0 and their weight to 1,2,3 respectively. This will divide the entire width of your screen into 3 columns in the proportion 1:2:3.

Here’s how your layout will look like:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginTop="16dp"
    android:orientation="horizontal">

    <TextView
        android:id="@+id/user_id"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:gravity="center"
        android:padding="4dp"
        android:text="id" />

    <TextView
        android:id="@+id/user_title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="2"
        android:gravity="center"
        android:padding="4dp"
        android:text="Title" />

    <TextView
        android:id="@+id/user_body"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="3"
        android:gravity="center"
        android:padding="4dp"
        android:text="Body" />

</LinearLayout>

Again, since this is not a design tutorial the UI might not look very pretty, so feel free to customize it as you like ?

Now with the layouts all done, we can head over to set up our android application in accordance with MVP Architecture. Again, if you aren’t really familiar with MVP, I strongly suggest that you have a look here: MVP Architecture in Android.

Phase 2: Setting up MVP Architecture

Creating the contract

Many people like to keep their View and Presenter interfaces in different files, but according to Google’s suggested guidelines, I like to create an outer interface (Wrapper) named Contract and then place my View and Presenter Interfaces inside it.

The benefit of this is that you won’t have to go looking at different files for the view and presenter associated with a single activity, it’s all in a single place. That’s how I like it, but feel free to explore other techniques.

So now let’s create a UserActivityContract. Create a new package named “contract”. Inside that package, create a new Java Interface UserActivityContract.

Within UserActivityContract, add two nested interfaces: View and Presenter. This is how your contract will look like at the end:

public interface UserContract {
    interface View {

    }

    interface Presenter {

    }

}

Now let’s add some methods to these. Let’s talk about the View first, we’ll be doing 3 major things inside our view:

• Initial setup of recyclerview (adding layout manager).
• Creating an adapter from recyclerview using the list of users obtained from the API.
• Showing some error message in case any error occurs.

So, let’s add a method for each one of these:

public interface UserContract {
    interface View {
        void init();

        void showError(String message);

        void loadDataInList(List<User> users);
    }

    interface Presenter {

    }

}

Next, let’s talk about the Presenter. The only real task of the presenter is to get the data from the API and send it to the View. So, add a method loadUsers() we’ll be making our API call here and passing the result to view if successful, else an error message.

public interface UserContract {
    interface View {
        void init();

        void showError(String message);

        void loadDataInList(List<User> users);
    }

    interface Presenter {

        void start();

        void loadUsers();
    }

}

Notice that apart from loadUsers(), we have also added a method named start(), this is more of like an initializer method for the presenter. You can perform all sorts of init tasks here such as initializing some variables, calling a method of the view to show some init messages etc. Here I’m using it to initialize the Recyclerview inside my UserActivity.java class.

Creating Presenter and Implementing View

Once done with the interfaces, it’s time to implement them.

Create a new class named UserPresenter and implement UserContract.Presenter on it and implement the required methods.

Now, open your UserActivity.java class and implement the interface UserContract.View and implement all the required methods. Add a field for the presenter in your activity and initialize it in onCreate as shown below:

mPresenter = new UserPresenter(this);
mPresenter.start();

This will call the constructor of our presenter and bind the View and Presenter together. When we call the start method on presenter, presenter in-turn calls the init() method which starts our initialization process.

With this, we finish Phase 2 of our project. Now let’s head over to Phase 3 and create our model class and a custom adapter to bind data to recyclerview.

Phase 3: Creating Model class for data and adapter for RecyclerView

Creating the model

Let’s go ahead and create our model which will be a POJO class for our data. If you look closely at the JSON response, it consists of 4 fields: id, userId, title, body. And all of this inside a JSON object. And many such JSON objects in an array. So, this is a fairly simple POJO class to create.

But before this, let’s add a dependency for GSON, which will be used to parse the JSON response. Add the following line to your dependencies:

implementation 'com.squareup.retrofit2:converter-gson:2.4.0'

Note: This is not the actual GSON dependency, this is a converter which uses GSON for serialization to and from JSON.

Now, create a package named model and inside it, create a java file named User. Add the four fields and annotate each of the fields with @SerializedName. Now let’s create getters and setters for the fields. Android Studio does this automatically for you, just press ALT+INS on your keyboard and select getters and setters.

This is how your POJO class would look like at the end:

public class User{

   @SerializedName("id")
   private int id;

   @SerializedName("title")
   private String title;

   @SerializedName("body")
   private String body;

   @SerializedName("userId")
   private int userId;

   public void setId(int id){
      this.id = id;
   }

   public int getId(){
      return id;
   }

   public void setTitle(String title){
      this.title = title;
   }

   public String getTitle(){
      return title;
   }

   public void setBody(String body){
      this.body = body;
   }

   public String getBody(){
      return body;
   }

   public void setUserId(int userId){
      this.userId = userId;
   }

   public int getUserId(){
      return userId;
   }

   @Override
   public String toString(){
      return 
         "User{" + 
         "id = '" + id + '\'' + 
         ",title = '" + title + '\'' + 
         ",body = '" + body + '\'' + 
         ",userId = '" + userId + '\'' + 
         "}";
      }
}

Note: toString method is optional. I like to include it because when printing log statements, it prints the formatted json.

Creating RecyclerView Adapter

Let’s now create the recyclerview adapter. Create a package named adapter and create a new Java class named CustomAdapter.java inside it. Extend the class from RecyclerView.Adapter class. It will show an error, just press ALT+Enter and override all the required methods.

Inside CustomAdapter.java create a nested class named MyViewHolder and extend it from RecyclerView.ViewHolder. Then create a constructor and initialize all the textviews as shown below:

public class CustomAdapter extends RecyclerView.Adapter<CustomAdapter.MyViewHolder> {

    public CustomAdapter(List<User> userList) {

    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    }

    @Override
    public void onBindViewHolder(MyViewHolder holder, int position) {

    }

    @Override
    public int getItemCount() {
        return userList.size();
    }

    public class MyViewHolder extends RecyclerView.ViewHolder {

        TextView tvId, tvTitle, tvBody;

        public MyViewHolder(View itemView) {
            super(itemView);
            tvId = (TextView) itemView.findViewById(R.id.user_id);
            tvTitle = (TextView) itemView.findViewById(R.id.user_title);
            tvBody = (TextView) itemView.findViewById(R.id.user_body);
        }
    }

}

We’ll be passing a list of users to this adapter and we would be doing that in the constructor. So, first create a field List<User> and then create a constructor which will take a List as its argument. Now, set the field property to the one obtained in the constructor.

When you overrode the methods, you got onCreateViewHolder. In that method, we’ll inflate our layout for the recyclerview item and return a view holder from it. Head over to onCreateViewHolder and add the following code:

@Override
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.recycler_item, parent, false);
    return new MyViewHolder(view);
}

Now, in onBindViewHolder, we’ll bind the data to our views. This is how the final adapter would look like:

public class CustomAdapter extends RecyclerView.Adapter<CustomAdapter.MyViewHolder> {

    List<User> userList = new ArrayList<>();

    public CustomAdapter(List<User> userList) {
        this.userList = userList;
    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.recycler_item, parent, false);
        return new MyViewHolder(view);
    }

    @Override
    public void onBindViewHolder(MyViewHolder holder, int position) {
        holder.tvTitle.setText(userList.get(position).getTitle());
        holder.tvId.setText(userList.get(position).getId()+"");
        holder.tvBody.setText(userList.get(position).getBody());
    }

    @Override
    public int getItemCount() {
        return userList.size();
    }

    public class MyViewHolder extends RecyclerView.ViewHolder {
        TextView tvId, tvTitle, tvBody;
        public MyViewHolder(View itemView) {
            super(itemView);
            tvId = (TextView) itemView.findViewById(R.id.user_id);
            tvTitle = (TextView) itemView.findViewById(R.id.user_title);
            tvBody = (TextView) itemView.findViewById(R.id.user_body);
        }
    }

}

Phase 4: Setting up Networking with Retrofit and RxJava

This is the crux of our android application. This is what you all came here for, so let’s get started.

I’ve divided setting up networking in our project into 4 parts:

• Creating a Retrofit adapter.
• Setting up an API Service interface which defines our endpoints.
• Creating a NetworkingUtil class to bind the Adapter and Service.
• Creating a Utility class to make API calls and return the result to the presenter.

So, let’s get started.

Creating a Retrofit Adapter

Create a package named “networking”, and inside networking, create another package named “adapter” (this is how I like my package management and is by no means the recommended way of doing things, but it suits me so +1).

Inside that package, create a class named RetrofitAdapter. In this class we’ll define the following things:

• A converter factory to parse JSON response into our POJO class.
• A call adapter factory.
• A base URL.

Let’s start by adding a BASE_URL filed at the top. Set the base URL to https://jsonplaceholder.typicode.com

Now, create a static instance of Gson and Retrofit at the top. Now, create a synchronized method as shown below and add the following code. I’ll explain what’s going on:

public static synchronized Retrofit getInstance() {

    if (retrofit == null) {
        if (gson == null) {
            gson = new GsonBuilder().setLenient().create();
        }

        retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();

    }

    return retrofit;
}

We are creating a singleton instance of retrofit, if the instance is already created, we just return it, else we create a new one.

To create a new instance, we are using the Retrofit.Builder() method. We set the Base URL to the URL declared at the top, we set the converter factory as Gson which will parse the JSON response for us and add a call adapter factory from RxJava 2.

Now, you may ask what is a call adapter? So, a call adapter is basically a tool which manages the execution, and response handling of retrofit. When the client receives a response from the server, it’s meaningless to the user as it is in bytes. So the call adapter converts those bytes into meaningful java objects.

To know more about call adapters take a look at this awesome article : https://futurestud.io/tutorials/retrofit-2-introduction-to-call-adapters

Since we have added RxJavaCallAdapter factory, it wraps our responses into RxJava types.

This is how our RetrofitAdapter.java class looks when complete:

public class RetrofitAdapter {

    private static Retrofit retrofit;
    private static Gson gson;
    private static final String BASE_URL = "https://jsonplaceholder.typicode.com";

    public static synchronized Retrofit getInstance() {

        if (retrofit == null) {
            if (gson == null) {
                gson = new GsonBuilder().setLenient().create();
            }

            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .build();

        }

        return retrofit;
    }

}

Creating an API Service

Now, we’ll create an interface to define our URL endpoints.

Create a package named API inside the networking package. Inside API, create a Java Interface named UserService.java

In our very short and concise example, we’ll be calling just a single endpoint, so we’ll have only one method. You can call many different endpoints such as for login, signup, logout etc…

Add a method declaration getUsers() and annotate it with the type of request (GET or POST) and pass the endpoint.

This is how your interface must look like at the end. Note that we are returning an Observable of type List, at the end. Our RxJava call adapter does the work of creating an observable out of the response from the server.

public interface UserService {

    @GET("/posts/")
    Observable<List<User>> getUsers();

}

Binding Adapter and Service

We need to bind our adapter class to the service. For this, create a utils package inside the networking package and create a new class named NetworkingUtils.

Create a static UserService instance and a method which will return a singleton instance of the userService.

This is how your NetworkingUtils would look like at the end:

public class NetworkingUtils {

    private static UserService userService;

    public static UserService getUserApiInstance() {
        if (userService == null)
            userService = RetrofitAdapter.getInstance().create(UserService.class);

        return userService;
    }

}

Creating a Utility class to make API calls

I’ve seen people do this in the Interactor. Interactor is just another layer in your MVP Architecture — some people prefer to include it, some don’t. In some projects, you’ll find Data Managers instead of an Interactor. It all comes down to your personal requirements/preference, but I personally don’t like using interactors (just like I don’t like JS :P) so I am creating a UserTask here.

But just before creating this class, let’s create a custom callback class which we can use to receive errors and results. In the root package, create a package named callback and create an interface named Callback inside this package. It will contain two methods, one for the result and other for error. This is how it’ll look like:

public abstract class Callback<T> {
    public abstract void returnResult(T t);
    public abstract void returnError(String message);
}

In the root package, create a package named utils. Inside this package create a java class named UserTask. This class will be responsible to make API calls and return the result to the presenter which will show the result or the error depending upon what we get.

If you aren’t familiar with RxJava, I strongly recommend having a look here: Understanding RxJava Basics.

I’ve explained all about how observeOn and subscribeOn work and what are their roles. Once you’ve gone through it, you’re good to go.

In our onNext method, we’ll return the result, and in onError, we’ll return the error.

This is how UserTask.java class looks like at the end:

public class UserTask {

    public static void getUsers(final Callback<List<User>> callback) {
        NetworkingUtils.getUserApiInstance()

                .getUsers()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<List<User>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(List<User> users) {
                        callback.returnResult(users);
                    }

                    @Override
                    public void onError(Throwable e) {
                        callback.returnError(e.getMessage());
                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

}

Finishing Up

With the major part of the work already done, we’re now left with passing the result from presenter to the view and setting the adapter for RecyclerView.

To do this, head over to UserPresenter.java class and in the loadUsers method, call UserTask.getUser() and provide a callback which returns the result or error.

In the returnResult method, we’ll call mView.loadDataInList() method passing a list of users successfully obtained. In the returnError method, we’ll call the mView.showError() method which’ll display errors if any. With this, our presenter class is complete, here’s how it looks like at the end:

public class UserPresenter implements UserContract.Presenter {
    UserContract.View mView;

    UserPresenter(UserContract.View mView) {
        this.mView = mView;
    }

    @Override
    public void loadUsers() {
        UserTask.getUsers(new Callback<List<User>>() {
            @Override
            public void returnResult(List<User> users) {
                mView.loadDataInList(users);
            }

            @Override
            public void returnError(String message) {
                mView.showError(message);
            }
        });
    }

    @Override
    public void start() {
        mView.init();
    }

}

In UserActivity.java, inside the loadDataInList method, instantiate our customAdapter and set it to recyclerview, and in showError method, just display a toast message. This is how our UserActivity.java looks like at the end:

public class UserActivity extends AppCompatActivity implements UserContract.View {

    private UserContract.Presenter mPresenter;
    private RecyclerView recyclerview;
    CustomAdapter adapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mPresenter = new UserPresenter(this);
        mPresenter.start();
    }

    @Override
    public void init() {
        recyclerview = findViewById(R.id.recyclerview);
        RecyclerView.LayoutManager manager = new LinearLayoutManager(this);
        recyclerview.setLayoutManager(manager);
        mPresenter.loadUsers();
    }

    @Override
    public void loadDataInList(List<User> users) {
        adapter = new CustomAdapter(users);
        recyclerview.setAdapter(adapter);
    }

    @Override
    public void showError(String message) {
        Toast.makeText(this,message,Toast.LENGTH_LONG).show();
    }

}

Conclusion

This is how you can set up your android application to use Retrofit, RxJava and MVP Architecture in tandem with each other. Let me know if you have any suggestions, in the comments section below or shoot me an email and I’ll respond asap ?

Like what you read? Don’t forget to share this post on Facebook, Whatsapp, and LinkedIn.

You can follow me on LinkedIn, Quora, Twitter, and Instagram where I answer questions related to Mobile Development, especially Android and Flutter.

If you want to stay updated with all the latest articles, subscribe to the weekly newsletter by entering your email address in the form on the top right section of this page.

Ok, so this isn’t new or anything, but I thought let’s just make a simple tutorial with the new Retrofit 2.0. This should give us a starting point.

This isn’t a tutorial for RxAndroid. If you don’t know much about RxAndroid, you should first check this out.

Let’s get into it then. Here are the things you’ll need before we start:

1. RxAndroid and Retrofit
2. Gson (I’ll be using Gson, you can use other parsers as well)
3. An Internet connection!

So after you’ve added the dependencies, your gradle files should look something like this (ignore the Retrolambda plugin, I just added it for code conciseness because… Lambdas! _):

Now you might be wondering, what is Retrofit exactly? Well, Retrofit is an HTTP Client, but it’s type-safe. That means you can transform an HTTP API into a Java Interface. This makes it ridiculously convenient to interact with the API.

The Starting Example

In the example, I’m going to use the OpenWeather API and I’ll keep it as simple as possible. I’ll just get the weather forecast for today in three steps.

Step 1: Generate Java Model (Pojo) classes from JSON

Here’s the API URL:

http://api.openweathermap.org/data/2.5/weather?q=London

And the response returned when you call it is:

{ “coord”: { “lon”: -0.13, “lat”: 51.51 }, “weather”: [ { “id”: 521, “main”: “Rain”, “description”: “shower rain”, “icon”: “09d” } ], “base”: “cmc stations”, “main”: { “temp”: 289.49, “pressure”: 993, “humidity”: 67, “temp_min”: 285.93, “temp_max”: 291.15 }, “wind”: { “speed”: 8.7, “deg”: 210, “gust”: 14.4 }, “rain”: { “1h”: 1.02 }, “clouds”: { “all”: 40 }, “dt”: 1442242382, “sys”: { “type”: 1, “id”: 5091, “message”: 0.0052, “country”: “GB”, “sunrise”: 1442208848, “sunset”: 1442254609 }, “id”: 2643743, “name”: “London”, “cod”: 200}

Looks pretty messy, right? Well, don’t worry, just go to this awesome website and paste in the JSON. It’ll come out looking like this:

If the JSON has to many model classes to be generated, the easier thing to do is generate a Jar and download it, extract it, and then add the files. Otherwise just click on Preview, and copy-paste the classes you need. Do remove the @Generated(“org.jsonschema2pojo”) from each model class, as this annotation isn’t recognized by Android by default.

I downloaded the Jar because there are a lot of classes. And also because I’m lazy. :)

After extracting and adding the classes, now the project tree looks something like this:

So far, so good!

Just an evil raccoon being evil.

Step 2: Create Retrofit Interface for your API calls

For Retrofit, you have to create an interface for the endpoints of your API.

When creating the interface, you should ask yourself: what exactly is the meaning of life? And secondly: what information do I need from the API?

For me, the answer to both questions is WeatherData (the top-most object). Now let’s examine the URL:

http://api.openweathermap.org/data/2.5/weather?q=London

There’s a query at the very end, so I’ll do this:

Note: in Retrofit 2.0, the endpoint path string should NOT start with “/”

@GET("/weather?") --> incorrect@GET("weather?")  --> correct

Now as parameter, I’ll send the query value using the @Query annotation.

As you’ll notice, I’m returning the Observable of WeatherData. That’s Rx right there!

Step 3: Create the Retrofit Adapter and WeatherService instance

Now in our Activity, we have to create a Retrofit adapter using the Base URL, along with some other info. Once built, we can initiate an object of WeatherService interface, then call the method.

Take a look at this delicious code:

So the question here is what the hell are those addCallAdapter and addConverterFactory methods doing there?

Well in order for our calls to return type Observable, we have to set the call adapter to RxJavaCallAdapter.

And addConverFactory is there to tell Retrofit which sort of converter I want it to use for serializing the JSON. I prefer the GSON converter. There are other converters available too.

So, for these two you need to add their dependencies to your gradle:

compile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'compile 'com.squareup.retrofit2:converter-gson:2.0.0'

Now run the code, and voila! It’ll log the weather description.

A Different Example

So yeah… Another example! Because why not? This time, I’ll try out the GitHub API. Again just 3 steps.

First, the API call URL:

https://api.github.com/users/ahmedrizwan

and the response:

{    "login": "ahmedrizwan",    "id": 4357275,    "avatar_url": "https://avatars.githubusercontent.com/u/4357275?v=3",    "gravatar_id": "",    "url": "https://api.github.com/users/ahmedrizwan",    "html_url": "https://github.com/ahmedrizwan",    "followers_url": "https://api.github.com/users/ahmedrizwan/followers",    "following_url": "https://api.github.com/users/ahmedrizwan/following{/other_user}",    "gists_url": "https://api.github.com/users/ahmedrizwan/gists{/gist_id}",    "starred_url": "https://api.github.com/users/ahmedrizwan/starred{/owner}{/repo}",    "subscriptions_url": "https://api.github.com/users/ahmedrizwan/subscriptions",    "organizations_url": "https://api.github.com/users/ahmedrizwan/orgs",    "repos_url": "https://api.github.com/users/ahmedrizwan/repos",    "events_url": "https://api.github.com/users/ahmedrizwan/events{/privacy}",    "received_events_url": "https://api.github.com/users/ahmedrizwan/received_events",    "type": "User",    "site_admin": false,    "name": "ahmed",    "company": null,    "blog": "https://medium.com/@ahmedrizwan",    "location": null,    "email": "ahmedrizwan@outlook.com",    "hireable": true,    "bio": null,    "public_repos": 19,    "public_gists": 0,    "followers": 25,    "following": 16,    "created_at": "2013-05-06T18:32:59Z",    "updated_at": "2016-07-08T11:29:26Z"}

Again, the JSON looks pretty messy.

Step 1: Generate the Pojos (plain old Java objects)

I copied the response and pasted it here (yet again):

And clicked on Preview.

Then I copied the Github class into my Project. music intensifies

Step 2: Create Interface for Endpoints

Now examine the API URL. And I mean, really examine it. You’ll see the endpoint starts from users and ends with the username.

https://api.github.com/users/ahmedrizwan

So the interface I created looks like this:

I created a call method, and used @Path annotation to replace the value of {username} in the EndPoint string dynamically.

Step 3: Create adapter and instance of GithubService

Here’s the beautiful code for doing just that:

You’ll notice I’m mapping the user object to String (you can do that with Rx. So Its output becomes:

So this is it. Although the article doesn’t cover everything Retrofit and RxAndroid can do (of course), I hope it will get you off to a good start.

Happy coding!