Sample of network state listener, connect or disconnect

NetworkStateMonitoringService.java

package ***.services;

import android.app.Activity;
import android.app.Application;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

/**
 * monitoring nerworking state, are connected to internet or not.
 * this class will send event to listener when stateChanged
 * or when current activity lifecycle is onResume
 */
public final class NetworkStateMonitoringService extends BroadcastReceiver
        implements Application.ActivityLifecycleCallbacks {

    public static final String TAG = NetworkStateMonitoringService.class.getSimpleName();

    private static ConnectionSateListener mConnectionSateListener;
    private static NetworkStateMonitoringService mInstance;
    private static IntentFilter mConnectivityIntentFilter;
    private static boolean isConnected;
    private static Activity mCurrentActivity;

    /**
     * assign this service to application context
     *
     * @param ctx      app context
     * @param listener
     * @return
     */
    public static NetworkStateMonitoringService with(Application ctx, ConnectionSateListener listener) {

        mInstance = new NetworkStateMonitoringService();
        mConnectivityIntentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
        mConnectionSateListener = listener;

        try {

            ConnectivityManager cm =
                    (ConnectivityManager) ctx
                            .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo netInfo = cm.getActiveNetworkInfo();
            isConnected = netInfo != null && netInfo.isConnected();
        } catch (Exception ignore) {
        }

        ctx.registerActivityLifecycleCallbacks(mInstance);
        return mInstance;
    }


    @Override
    public void onReceive(Context context, Intent intent) {

        if (intent == null) return;

        isConnected = !intent.getBooleanExtra(
                ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);

        dispatchListener(mCurrentActivity);

    }

    void dispatchListener(Activity activity) {
        mCurrentActivity = activity;
        if (mConnectionSateListener != null)
            mConnectionSateListener.onConnectionStateChanged(activity, isConnected);
    }

    /**
     *
     */
    public interface ConnectionSateListener {
        void onConnectionStateChanged(@Nullable Activity activity, boolean isConnected);
    }

    //region Application.ActivityLifecycleCallbacks
    @Override
    public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState) {
        activity.registerReceiver(this, mConnectivityIntentFilter);
    }

    @Override
    public void onActivityStarted(@NonNull Activity activity) {

    }

    @Override
    public void onActivityResumed(@NonNull Activity activity) {
        dispatchListener(activity);
    }

    @Override
    public void onActivityPaused(@NonNull Activity activity) {

    }

    @Override
    public void onActivityStopped(@NonNull Activity activity) {

    }

    @Override
    public void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle outState) {

    }

    @Override
    public void onActivityDestroyed(@NonNull Activity activity) {
        activity.unregisterReceiver(this);
    }

    //endregion
}

equivalent in kotlin

import android.app.Activity
import android.app.Application
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.NetworkInfo
import android.os.Bundle

/**
 * monitoring nerworking state, are connected to internet or not.
 * this class will send event to listener when stateChanged
 * or when current activity lifecycle is onResume
 */
class NetworkStateMonitoringService : BroadcastReceiver(), Application.ActivityLifecycleCallbacks {
    override fun onReceive(context: Context, intent: Intent) {
        if (intent == null) return
        isConnected = context.isConnectionConnected()

        dispatchListener()
    }

    fun dispatchListener(activity: Activity? = mCurrentActivity) {
        mCurrentActivity = activity
        mConnectionSateListener?.onConnectionStateChanged(activity, isConnected)
    }


    /**
     *
     */
    interface ConnectionSateListener {
        fun onConnectionStateChanged(activity: Activity?, isConnected: Boolean)
    }

    //region Application.ActivityLifecycleCallbacks
    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        mCurrentActivity = activity
        activity.registerReceiver(this, mConnectivityIntentFilter)
    }

    override fun onActivityStarted(activity: Activity) {}
    override fun onActivityResumed(activity: Activity) {
//        dispatchListener(activity)
        mCurrentActivity = activity
    }

    override fun onActivityPaused(activity: Activity) {}
    override fun onActivityStopped(activity: Activity) {}
    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
    override fun onActivityPreDestroyed(activity: Activity) {
        goAsync()
        if (activity.javaClass.equals(mCurrentActivity?.javaClass))
            mCurrentActivity = null
        activity.unregisterReceiver(this)
    }

    override fun onActivityDestroyed(activity: Activity) {
    } //endregion

    companion object {
        private var mConnectionSateListener: ConnectionSateListener? = null
        private var mInstance: NetworkStateMonitoringService? = null
        private var mConnectivityIntentFilter: IntentFilter? = null
        private var isConnected = false
        private var mCurrentActivity: Activity? = null
        fun Context.isConnectionConnected(): Boolean{
            try {
                val cm = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
                val netInfo = cm.activeNetworkInfo
                return netInfo != null && netInfo.isConnected
            } catch (ignore: Exception) {
            }
            return false
        }
        /**
         * assign this service to application context
         *
         * @param ctx      app context
         * @param listener
         * @return
         */
        fun with(ctx: Application, listener: ConnectionSateListener): NetworkStateMonitoringService? {
            mInstance = NetworkStateMonitoringService()
            mConnectivityIntentFilter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
            mConnectionSateListener = listener
            isConnected = ctx.isConnectionConnected()
            ctx.registerActivityLifecycleCallbacks(mInstance)
            return mInstance
        }
    }
}