Check connection at every instant

Question

The thing is, I’m creating an app that depends on the internet connection for most services. To make it more dynamic, I thought I’d do something similar to the Youtube app. In the youtube app it warns almost instantly that the app is disconnected. See:

I did a general search and tried to make use of Threads in two ways:

1. Executor + Runnable

      class ThreadInfinity implements Executor {

            @Override
           public void execute(@NonNull Runnable r) {

                while (true) {
                    r.run();
                }

            }
        }

        Thread r = new Thread(new Runnable() {
            @Override
            public void run() {

                    if (manager.getActiveNetworkInfo() != null && manager.getActiveNetworkInfo().isConnectedOrConnecting()) {

                         Toast.makeText(getApplicationContext(), "Você está conectado", Toast.LENGTH_SHORT);

                    } else {

                         Toast.makeText(getApplicationContext(), "Você está desconectado", Toast.LENGTH_SHORT);

                    }

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        });

        ThreadInfinity t = new ThreadInfinity();
        t.execute(r);

2. Asynctask

        Context context = getApplicationContext();
        final ConnectivityManager manager = (ConnectivityManager) context.getSystemService(context.CONNECTIVITY_SERVICE);

        class TheadInfinity extends AsyncTask<Void, Void, Void> {
            protected Void doInBackground(Void... params) {
                while (true)
                    try {
                        if (manager.getActiveNetworkInfo() != null && manager.getActiveNetworkInfo().isConnectedOrConnecting()) {

                             Toast.makeText(getApplicationContext(), "Você está conectado", Toast.LENGTH_SHORT);

                        } else {

                             Toast.makeText(getApplicationContext(), "Você está desconectado", Toast.LENGTH_SHORT);

                        }
                        Thread.sleep(1000);

                    } catch (Exception e) {
                        Toast.makeText(getApplicationContext(), "Erro", Toast.LENGTH_SHORT);
                    }
            }
        }

        TheadInfinity t = new TheadInfinity();
        t.doInBackground();

Both do not lock the application but the screen is blank. So:

I believe the correct mode is not with Thread. There must be some Systems that can be used. However I have not found anywhere "on the internet".

Doubt

How can I do that? =)

Answer 1

I use this class in my projects:

public class ConexaoInternet extends BroadcastReceiver {

    public enum TipoConexao {TIPO_NAO_CONECTADO,TIPO_WIFI, TIPO_MOBILE};

    private  TipoConexao tipoConexaoATUAL = TipoConexao.TIPO_NAO_CONECTADO; //cache
    private boolean inicializou = false;

    private TipoConexao getStatusConexao(Context context) {
        synchronized (tipoConexaoATUAL){
            ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            tipoConexaoATUAL = TipoConexao.TIPO_NAO_CONECTADO;

            NetworkInfo activeNetwork = cm==null ? null : cm.getActiveNetworkInfo();
            if (null != activeNetwork) {
                if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                    tipoConexaoATUAL = TipoConexao.TIPO_WIFI;
                }
                if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE){
                    tipoConexaoATUAL = TipoConexao.TIPO_MOBILE;
                }
            }

            return tipoConexaoATUAL;
        }
    }

    public TipoConexao getTipoConexaoAtual(Context context){
        if(!inicializou){
            inicializou = true;
            return getStatusConexao(context);
        }
        return tipoConexaoATUAL;
    }

    public interface IOnMudarEstadoConexao{
        void onMudar(TipoConexao tipoConexao);
    }
    private ArrayList<IOnMudarEstadoConexao> onMudarEstadoConexoesListeners = new ArrayList<>();

    public void addOnMudarEstadoConexao(IOnMudarEstadoConexao t){
        onMudarEstadoConexoesListeners.add(t);
    }
    public void removeOnMudarEstadoConexao(IOnMudarEstadoConexao t){
        onMudarEstadoConexoesListeners.remove(t);
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        TipoConexao tipo = getStatusConexao(context);

        for(IOnMudarEstadoConexao o : onMudarEstadoConexoesListeners){
            o.onMudar(tipo);
        }

        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            if(connectivityManager!=null){
                for (Network net : connectivityManager.getAllNetworks()) {
                    NetworkInfo networkInfo = connectivityManager.getNetworkInfo(net);
                    if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
                        connectivityManager.bindProcessToNetwork(net);
                        break;
                    }
                }
            }
        }
    }
}

It is necessary to register when the Activity is created

private ConexaoInternet conexaoInternet;

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

    IntentFilter intentFilter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
    intentFilter.addAction("android.net.wifi.WIFI_STATE_CHANGED");
    conexaoInternet = new ConexaoInternet();
    registerReceiver(conexaoInternet,intentFilter);

It is necessary to remove when Activity is destroyed

@Override
protected void onDestroy() {
    super.onDestroy();
    unregisterReceiver(conexaoInternet);
}

Example: To add a Switch every time the device changes its connection

conexaoInternet.addOnMudarEstadoConexao(
    new ConexaoInternet.IOnMudarEstadoConexao() {
        @Override
        public void onMudar(ConexaoInternet.TipoConexao tipoConexao) {
            if(tipoConexao == ConexaoInternet.TipoConexao.TIPO_MOBILE ||
                            tipoConexao == ConexaoInternet.TipoConexao.TIPO_WIFI){

                //faça algo quando a conexão for alterada para 3g/wifi

            }else if(tipoConexao == ConexaoInternet.TipoConexao.TIPO_NAO_CONECTADO){

               //faça algo quando o dispositivo perder conexão

            }
        }
    }
);

Answer 2

First you need to map a action on Androidmanifest.xml:

<action android:name="android.net.conn.CONNECTIVITY_CHANGE"/>

Then it will be possible to create a receiver so that you have an action to do when the connection type changes:

public class ConnectionChanged extends BroadcastReceiver {

    private final String ACTION_CONN_CHANGED = "android.net.conn.CONNECTIVITY_CHANGE";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction() != null && intent.getAction().equals(ACTION_CONN_CHANGED)) {

            //TODO SEU CODIGO
        }
    }
}

And do as @Digaopartnered said, check what type of connection through a modeling and take a second action for each type of connection.

boolean isWiFi = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;

More details in the Android documentation: Determine and monitor connectivity status