Gérer la connexion Internet sur Android Nougat ou Android Oreo avec l'économiseur de batterie activé

Question

J'ai des problèmes avec la gestion correcte de la connexion Internet sur les nouvelles versions Android lorsque l'appareil est déverrouillé avec l'économiseur de batterie activé.

Les autorisations android.permission.INTERNET et android.permission.ACCESS_NETWORK_STATE sont ajoutées au fichier manifeste.

Je enregistre la diffusion reçue pour écouter ConnectivityManager.CONNECTIVITY_ACTION lorsque l'activité est démarrée et désenregistrer lorsqu'elle est arrêtée. Il fonctionne parfaitement lorsqu'il est désactivé manuellement \ activer Wi-FI ou connexion cellulaire.

J'utilise également la méthode pour vérifier la connexion

private boolean isNetworkAvailable() { 
     ConnectivityManager conn = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 
     NetworkInfo networkInfo = conn.getActiveNetworkInfo(); 
     return null != networkInfo && networkInfo.isConnected(); 
    } 

Chaque fois que lorsque le téléphone est déverrouillé et ma demande est sur la méthode renvoie au premier plan isNetworkAvailable() est connecté, mais il n'est pas.

J'ai essayé de mettre en œuvre quelque chose comme la logique de ping, mais après déverrouiller le téléphone que je reçois pas connecté tout le temps jusqu'à ce que désactiver le mode économiseur de batterie

try { 
     InetAddress inetAddress = InetAddress.getByName("www.google.com"); 
     if (inetAddress.isReachable(1000)) { 
      // IS CONNECTED 
     } 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    // IS NOT CONNECTED 

Est-ce que quelqu'un connaît une bonne solution comment connexion gérer sur Android 7 & Android 8 ?

Merci d'avance

code source Activité:

public class MainActivity extends AppCompatActivity implements ConnectionManager.ConnectionStatusListener { 

private TextView textView; 

private ConnectionManager cm; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 
    textView = (TextView) findViewById(R.id.textView); 
    cm = new ConnectionManager(getBaseContext()); 
    //Show by default is disconnected 
    disconnected(); 
} 

@Override 
protected void onStart() { 
    super.onStart(); 
    cm.register(this); 
} 

@Override 
protected void onStop() { 
    super.onStop(); 
    cm.unregister(this); 
} 


// ConnectionManager.ConnectionStatusListener implementation 
@Override 
public void connected() { 
    textView.setText("Connected"); 
    textView.setTextColor(Color.GREEN); 
} 

@Override 
public void disconnected() { 
    textView.setText("Disconnected"); 
    textView.setTextColor(Color.RED); 
} 
} 

Ma mise en œuvre du gestionnaire de connexion:

class ConnectionManager { 
private final Context context; 
private final Object syncObj = new Object(); 
private final LinkedList<ConnectionStatusListener> listeners = new LinkedList<>(); 
private final Handler uiHandler; 
private final Handler ioHandler; 


private final BroadcastReceiver connectivityActionBR = new BroadcastReceiver() { 
    @Override 
    public void onReceive(Context context, Intent intent) { 
     updateConnStatus(); 
    } 
}; 
private final Runnable pingRunnable = new Runnable() { 
    @Override 
    public void run() { 
     try { 
      InetAddress inetAddress = InetAddress.getByName("www.google.com"); 
      if (!inetAddress.isReachable(1000)) { 
       notifyListeners(false); 
       startPingServerDelayed(500); 
      } else { 
       notifyListeners(true); 
      } 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 
}; 

public ConnectionManager(Context context) { 
    this.context = context; 

    uiHandler = new Handler(); 

    HandlerThread handlerThread = new HandlerThread("checkInternetConnectionThread"); 
    handlerThread.start(); 
    ioHandler = new Handler(handlerThread.getLooper()); 
    // TODO: 9/18/17 add destroy to stop threadHandler 
} 


public void register(ConnectionStatusListener listener) { 
    synchronized (syncObj) { 
     if (!listeners.contains(listener)) { 
      listeners.add(listener); 
     } 

     registerBR(); 
    } 
} 

public void unregister(ConnectionStatusListener listener) { 
    synchronized (syncObj) { 
     listeners.remove(listener); 
    } 

    unregisterBR(); 
    stopPingServer(); 
} 


private void registerBR() { 
    context.registerReceiver(connectivityActionBR, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)); 
} 

private void unregisterBR() { 
    context.unregisterReceiver(connectivityActionBR); 
} 

private void notifyListeners(final boolean isConnected) { 
    Log.e("---", "isConnected=" + isConnected); 
    uiHandler.post(new Runnable() { 
     @Override 
     public void run() { 
      synchronized (syncObj) { 
       for(ConnectionStatusListener listener : listeners) { 
        if (isConnected) { 
         listener.connected(); 
        } else { 
         listener.disconnected(); 
        } 
       } 
      } 
     } 
    }); 

} 

private void updateConnStatus() { 
    if (!isNetworkAvailable()) { 
     stopPingServer(); 
     notifyListeners(false); 
    } 

    startPingServerNow(); 
} 

private void startPingServerDelayed(long millis) { 
    ioHandler.postDelayed(pingRunnable, millis); 
} 
private void startPingServerNow() { 
    ioHandler.post(pingRunnable); 
} 

private void stopPingServer() { 
    ioHandler.removeCallbacks(pingRunnable); 
} 

private boolean isNetworkAvailable() { 
    ConnectivityManager conn = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); 
    NetworkInfo networkInfo = conn.getActiveNetworkInfo(); 
    return null != networkInfo && networkInfo.isConnectedOrConnecting(); 
} 


public interface ConnectionStatusListener { 
    void connected(); 

    void disconnected(); 
} 
} 

Answer 1

Enregistrez votre émission dans onCreate() désinscriptions dans OnDestroy (). Laissez-moi, ce que vous avez doit travailler.