Network monitoring class using Android architecture components

ConnectivityMonitor.java

package xyz.android.amrro.example;

import android.arch.lifecycle.Lifecycle;
import android.arch.lifecycle.LifecycleObserver;
import android.arch.lifecycle.MutableLiveData;
import android.arch.lifecycle.OnLifecycleEvent;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.support.annotation.NonNull;

import java.util.Objects;

/**
 * Created by amrro <amr.elghobary@gmail.com> on 8/15/17.
 * <p>
 * This class handle connectivity and detect if available.
 */

public final class ConnectivityMonitor implements LifecycleObserver {

    private ConnectivityManager manager;
    private MutableLiveData<Boolean> isConnected = new MutableLiveData<>();
    private boolean monitoring = false;
    private ConnectivityManager.NetworkCallback connectivityCallback
            = new ConnectivityManager.NetworkCallback() {
        @Override
        public void onAvailable(Network network) {
            isConnected.postValue(true);
        }

        @Override
        public void onLost(Network network) {
            isConnected.postValue(false);
        }
    };

    public ConnectivityMonitor(@NonNull final Context context) {
        Objects.requireNonNull(context, "_> context cannot be null.");
        manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
    }

    private void checkConnectivity() {
        final NetworkInfo activeNetworkInfo = manager.getActiveNetworkInfo();
        final boolean connection = activeNetworkInfo != null && activeNetworkInfo.isConnected();
        if (connection) {
            isConnected.setValue(connection);
        } else {
            isConnected.setValue(false);
            manager.registerNetworkCallback(
                    new NetworkRequest.Builder()
                            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build(),
                    connectivityCallback
            );
            monitoring = true;
        }
    }

    @NonNull
    public MutableLiveData<Boolean> isConnected() {
        return isConnected;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        checkConnectivity();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        if (monitoring) {
            manager.unregisterNetworkCallback(connectivityCallback);
            monitoring = false;
        }
    }
}

ExampleActivity.java

package xyz.android.amrro.example.ui.main;

import android.arch.lifecycle.LifecycleActivity;
import android.databinding.DataBindingUtil;
import android.os.Bundle;
import dagger.android.AndroidInjection;
import timber.log.Timber;
import xyz.android.amrro.recipes.ConnectivityMonitor;
import xyz.android.amrro.recipes.R;
import xyz.android.amrro.recipes.databinding.ActivityRecipesListBinding;

public class ExampleActivity extends LifecycleActivity {

    private ActivityExampleBinding binding;
    private ConnectivityMonitor monitor;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        AndroidInjection.inject(this);
        super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this, R.layout.activity_example);
        
        monitor = new ConnectivityMonitor(this);
        getLifecycle().addObserver(monitor);
        monitor.isConnected().observe(this, isConnected -> {
            if (isConnected) {
                Timber.i("_> is connected: " + isConnected);
            }
        });
    }
}