tengo - Evento de Android para el cambio de estado de conectividad a Internet

manual de programacion android pdf

Question

Estoy creando una aplicación en la que un usuario carga información y archivos en mi servidor con cierta frecuencia. Esto se realiza en nuevos subprocesos a través de un servicio de carga dedicado.

Lo sé por este hilo

Detecta si hay una conexión a Internet disponible en Android

que puede verificar si hay una conexión a internet con relativa facilidad. También puede obtener socketTimeoutExceptions para detectar problemas de conectividad a Internet. Todo está muy bien, y me permite almacenar en caché mis cargas con la suficiente facilidad cuando la conexión no funcionó por el motivo que sea.

Mi pregunta, sin embargo, es ¿cómo puedo saber cuándo volver a intentar la carga? ¿Hay un evento activado cuando se restablece la conexión? ¿O estoy atrapado haciendo un nuevo hilo que duerme y luego compruebo la conectividad a Internet cada 30 segundos o algo así?

¡Cualquier idea sería apreciada!

Answer 1

Android Nougat & O (API 24+) - Estado de la red

Cambia mades a @darnmason answer (constructor) para que funcione en API 24+ .

public NetworkStateReceiver(Context context) {
    mListeners =  new ArrayList<>();
    mManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);

    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    context.registerReceiver(NetworkStateReceiver.this, intentFilter);

    checkStateChanged();
}

Answer 2

Hay un receptor de transmisión para cambios de conectividad. Mira here

Answer 3

No estoy seguro de lo que estaba sucediendo en el receptor de transmisión de Tommaso, pero no funcionaba para mí, aquí está mi implementación. Solo se notifica sobre el cambio entre la conectividad disponible / no disponible.

También lo registro en onResume() y onPause() registro en onPause() . De lo contrario, es lo mismo que arriba.

public class NetworkStateReceiver extends BroadcastReceiver {

    private ConnectivityManager mManager;
    private List<NetworkStateReceiverListener> mListeners;
    private boolean mConnected;

    public NetworkStateReceiver(Context context) {
        mListeners = new ArrayList<NetworkStateReceiverListener>();
        mManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        checkStateChanged();
    }

    public void onReceive(Context context, Intent intent) {
        if (intent == null || intent.getExtras() == null)
            return;

        if (checkStateChanged()) notifyStateToAll();
    }

    private boolean checkStateChanged() {
        boolean prev = mConnected;
        NetworkInfo activeNetwork = mManager.getActiveNetworkInfo();
        mConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting();
        return prev != mConnected;
    }

    private void notifyStateToAll() {
        for (NetworkStateReceiverListener listener : mListeners) {
            notifyState(listener);
        }
    }

    private void notifyState(NetworkStateReceiverListener listener) {
        if (listener != null) {
            if (mConnected) listener.onNetworkAvailable();
            else listener.onNetworkUnavailable();
        }
    }

    public void addListener(NetworkStateReceiverListener l) {
        mListeners.add(l);
        notifyState(l);
    }

    public void removeListener(NetworkStateReceiverListener l) {
        mListeners.remove(l);
    }

    public interface NetworkStateReceiverListener {
        public void onNetworkAvailable();

        public void onNetworkUnavailable();
    }
}

Answer 4

Si solo quiere hacer algo simple cuando la conectividad cambia, hay una solución mucho más fácil.

En tu actividad, crea un receptor de difusión:

private BroadcastReceiver networkStateReceiver=new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = manager.getActiveNetworkInfo();
        doSomethingOnNetworkChange(ni);
    }
};

Luego en onResume y onPause haz el registro:

@Override
public void onResume() {
    super.onResume();
    registerReceiver(networkStateReceiver, new IntentFilter(android.net.ConnectivityManager.CONNECTIVITY_ACTION));
}

@Override
public void onPause() {
    unregisterReceiver(networkStateReceiver);
    super.onPause();
}

Answer 5

publicación muy antigua, pero me gustaría compartir mi receptor

no es necesario poner sus manos en manifiestos u otros recursos aburridos :)

USO

TU ACTIVIDAD:

/*
 * You need to implement NetworkStateReceiverListener.
 * This interface is described inside the NewtworkStateReceiver class
 */
public class MyActivity implements NetworkStateReceiverListener {
    /* ... */
    private NetworkStateReceiver networkStateReceiver;
}

EN TU ACTIVIDAD: INSTANCIA EL RECEPTOR

public void onCreate(Bundle savedInstanceState) {
    /* ... */
    networkStateReceiver = new NetworkStateReceiver();
    networkStateReceiver.addListener(this);
    this.registerReceiver(networkStateReceiver, new IntentFilter(android.net.ConnectivityManager.CONNECTIVITY_ACTION));
}

public void onDestroy() {
    super.onDestroy();
    networkStateReceiver.removeListener(this);
    this.unregisterReceiver(networkStateReceiver);
}

EN SU ACTIVIDAD: IMPLEMENTA LOS MÉTODOS REQUERIDOS

@Override
public void networkAvailable() {
    Log.d("tommydevall", "I''m in, baby!");
    /* TODO: Your connection-oriented stuff here */
}

@Override
public void networkUnavailable() {
    Log.d("tommydevall", "I''m dancing with myself");
    /* TODO: Your disconnection-oriented stuff here */        
}

EL RECEPTOR

solo copie y pegue en su proyecto como NetworkStateReceiver.java

public class NetworkStateReceiver extends BroadcastReceiver {

    protected Set<NetworkStateReceiverListener> listeners;
    protected Boolean connected;

    public NetworkStateReceiver() {
        listeners = new HashSet<NetworkStateReceiverListener>();
        connected = null;
    }

    public void onReceive(Context context, Intent intent) {
        if(intent == null || intent.getExtras() == null)
            return;

        ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = manager.getActiveNetworkInfo();

        if(ni != null && ni.getState() == NetworkInfo.State.CONNECTED) {
            connected = true;
        } else if(intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY,Boolean.FALSE)) {
            connected = false;
        }

        notifyStateToAll();
    }

    private void notifyStateToAll() {
        for(NetworkStateReceiverListener listener : listeners)
            notifyState(listener);
    }

    private void notifyState(NetworkStateReceiverListener listener) {
        if(connected == null || listener == null)
            return;

        if(connected == true)
            listener.networkAvailable();
        else
            listener.networkUnavailable();
    }

    public void addListener(NetworkStateReceiverListener l) {
        listeners.add(l);
        notifyState(l);
    }

    public void removeListener(NetworkStateReceiverListener l) {
        listeners.remove(l);
    }

    public interface NetworkStateReceiverListener {
        public void networkAvailable();
        public void networkUnavailable();
    }
}

DISFRUTAR;)