Question: I am getting a complex `json` from an `api` and I am saving the values with `Architect component(Room)`.

Question: 

* Can I compare current values with last values that I saved in `SQlite` and if in compare I find a difference, update the `RecyclerView`?
* Is this method logical?
* Do you have a better way to offer?
* If you have a better way to offer get me a sample(url sample)

Answer: 
Yes, you can do that and it is actually the recommended way. In order to do so, I think you should leverage the use of two other Architecture Components that were introduced with Android Jetpack, not only `Room` database: [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel) and [LiveData](https://developer.android.com/topic/libraries/architecture/livedata), but it is not mandatory. 

The important thing is to add an extra layer to your app called `Repository`:

> 
> **Repository** modules handle data operations. They provide a clean API so
>  that the rest of the app can retrieve this data easily. They know
>  where to get the data from and what API calls to make when data is
>  updated. You can consider repositories to be mediators between
>  different data sources, such as persistent models, web services, and
>  caches.
> 
> 
> 

So basically, the suggested architecture to handle this will look something like this:

[![Android recommended architecture](https://i.stack.imgur.com/VCdAM.png)](https://i.stack.imgur.com/VCdAM.png)

With that in mind, an example of a Repository that retrieves User data from a web service and save it to a local Room Database will look something like this:

```
public class UserRepository {
    private final Webservice webservice;
    private final UserDao userDao;
    private final Executor executor;

    public UserRepository(Webservice webservice, UserDao userDao, Executor executor) {
        this.webservice = webservice;
        this.userDao = userDao;
        this.executor = executor;
    }

    public LiveData<User> getUser(String userId) {
        refreshUser(userId);
        // Returns a LiveData object directly from the database.
        return userDao.load(userId);
    }

    private void refreshUser(final String userId) {
        // Runs in a background thread.
        executor.execute(() -> {
            // Check if user data was fetched recently.
            boolean userExists = userDao.hasUser(FRESH_TIMEOUT);
            if (!userExists) {
                // Refreshes the data.
                Response<User> response = webservice.getUser(userId).execute();

                // Check for errors here.

                // Updates the database. The LiveData object automatically
                // refreshes, so we don't need to do anything else here.
                userDao.save(response.body());
            }
        });
    }
}

```

Then, your ViewModel will get the User Live Data doing something like this:

```
...
user = userRepo.getUser(userId);
...

```

And it will provide that LiveData to the UI layer with a public method:

```
...
public LiveData<User> getUser() {
        return this.user;
}
...

```

Finally, from your UI layer (an Activity or Fragment) you can **observe** the LiveData in the ViewModel and adapt the UI accordingly.

```
viewModel.getUser().observe(this, user -> {
      // Update UI.
});

```

For a more complete explanation I suggest that you take a look to:

1. [Guide to app architecture in Android`s Developers website.](https://developer.android.com/jetpack/docs/guide)
2. [This Github project with a basic example.](https://github.com/googlesamples/android-architecture-components/tree/master/BasicSample)
3. [This other Github project with a more complex example.](https://github.com/googlesamples/android-architecture-components/tree/master/GithubBrowserSample)
You can merge multiple live data source from server and sqlite with MediatorLiveData which is a subclass of LiveData. 

For example, if you have a LiveData object in your UI that can be updated from a local database or a network, then you can add the following sources to the MediatorLiveData object:

```
A LiveData object associated with the data stored in the database.
A LiveData object associated with the data accessed from the network.

```

[Documentation](https://developer.android.com/topic/libraries/architecture/livedata#java)