Servizi WebSocket Android che effettuano più connessioni

Question

Ho creato un servizio Web Socket. ma continua a effettuare connessioni multiple

Voglio solo che l'app effettui una connessione, a meno che la connessione di rete non scada e ne facciane un'altra. Ma al momento, crea una connessione, se premo il tasto Home sul telefono. e torna sull'app, farà un'altra connessione.

Grazie per il vostro aiuto ragazzi.

onCreate ... della mia MainActivity

Intent startServiceIntent = new Intent(this, WebSocketServices.class); 
     startService(startServiceIntent); 

manifesto

<!-- WebSocket --> 
<receiver 
    android:name="com.example.basicplayerapp.core.NetworkReceiver"> 
    <intent-filter > 
     <action android:name="android.net.conn.CONNECTIVITY_CHANGE" /> 
     <action android:name="android.intent.action.BOOT_COMPLETED" /> 
    </intent-filter> 
</receiver> 
<service android:name="com.example.basicplayerapp.core.WebSocketServices"></service> 

NetworkReceiver

public class NetworkReceiver extends BroadcastReceiver { 
    public static final String TAG = HomeActivity.class.getSimpleName(); 

    @Override 
    public void onReceive(Context context, Intent intent) {   
     ConnectivityManager conn = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE); 
     NetworkInfo networkInfo = conn.getActiveNetworkInfo(); 

     if (networkInfo != null && networkInfo.getDetailedState() == NetworkInfo.DetailedState.CONNECTED) { 
      Log.i(TAG, "connected"); 

      Intent startServiceIntent = new Intent(context, WebSocketServices.class); 
      context.startService(startServiceIntent); 

     } 
     else if(networkInfo != null){ 
      NetworkInfo.DetailedState state = networkInfo.getDetailedState(); 
      Log.i(TAG, state.name()); 
     } 
     else { 
      Log.i(TAG, "lost connection"); 

     } 


    }//end onReceive  
};//end NetworkReceiver 

WebsocketServices

public class WebSocketServices extends IntentService { 
    public static final String TAG = WebSocketServices.class.getSimpleName(); 

    private static String SOCKET_ADDR = "http://171.0.0.1:8080"; 
    private String message = null; 
    private WebSocket socket = null; 

    public WebSocketServices() { 
     super("DownloadService"); 
    } 


    @Override 
    protected void onHandleIntent(Intent intent) { 
     Log.i(TAG, "onHandleIntent"); 

     //SOCKET_ADDR = intent.getStringExtra("ip"); 

     if(socket==null || !socket.isOpen() || socket.isPaused()) 
     connectToPASocket(SOCKET_ADDR); 

     Log.d(TAG,"Service Invoke Function"); 
    }//end onHandleIntent 






    //===================================================================================== 
    // Socket connection 
    //===================================================================================== 
    private void connectToPASocket(String SOCKET_ADDR) { 
     Log.i(TAG, "connectToPASocket()"); 

     // Checking 
     if (socket != null && socket.isOpen()) return; 


     // Initiate web socket connection 
     AsyncHttpClient.getDefaultInstance().websocket(SOCKET_ADDR, null, 
       new AsyncHttpClient.WebSocketConnectCallback() { 
        @Override 
        public void onCompleted(Exception ex, WebSocket webSocket) { 
         Log.i(TAG, "onCompleted"); 

         if (ex != null) { 
          Log.i(TAG, "onCompleted > if (ex != null)"); 
          ex.printStackTrace(); 
          return; 
         } 

         socket = webSocket; 
         socket.setStringCallback(new StringCallback() { 
          public void onStringAvailable(String s) { 
           Log.i(TAG, "socket.setStringCallback > onStringAvailable - s => " + s); 

           System.out.println("I got a string: " + s); 
           message = s; 



          }// end onStringAvailable 
         });// end socket.setStringCallback 

         socket.setDataCallback(new DataCallback() { // Find out what this does 
          @Override 
          public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) { 
           Log.i(TAG, "socket.setDataCallback > onDataAvailable | emitter=> " + emitter + " | bb => " + bb); 

           System.out.println("I got some bytes!"); 
           // note that this data has been read 
           bb.recycle(); 
          } 
         });// end webSocket.setDataCallback 

        }// end onCompleted 
       });// end AsyncHttpClient.getDefaultInstance() 
    }// end connectToPASocket 
}//end WebSocketServices 

Answer 1

MrT, ho avuto un problema simile.

Non utilizzare intentService. Basta usare il servizio. Perché una volta che intentService è stato fatto, finirà da solo.

Dopo la modifica al servizio, cosa si può fare, è quello di utilizzare booleano per verificare se il servizio è stato avviato in questo modo:

boolean isSockeStarted = false; 



    @Override 
    public int onStartCommand(Intent intent, int flags, int startId) { 
... 


     if (socket == null || !socket.isOpen() || socket.isPaused()) { 

      if (isSockeStarted) { //not started 
      } else { 
       isSockeStarted = true; 
      } 
     } 
.... 

Che dire, questo servizio avrà inizio solo una volta. finché non lo uccidi manualmente.

ha funzionato per me, prova e fammi sapere.

Answer 2

Prova a filtrare le azioni nel metodo OnReceive - qualcosa come if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction()))

Answer 3

E 'successo perché dopo il tuo ritorno a app onCreate sarà chiamata per la seconda volta ed è fare un altro collegamento alla presa di corrente. in modo da poter semplice non avviare un altro servizio se l'IntentService è ancora in esecuzione, qualcosa di simile:

onCreate ... di MainActivity

if(isMyServiceRunning(WebSocketServices.class)){ 
Intent startServiceIntent = new Intent(this, WebSocketServices.class); 
    startService(startServiceIntent); 
} 

metodo per vedere se il servizio è in esecuzione

private boolean isMyServiceRunning(Class<?> serviceClass) { 
ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); 
for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) { 
    if (serviceClass.getName().equals(service.service.getClassName())) { 
     return true; 
    } 
} 
return false; 
} 

Answer 4

È necessario utilizzare un servizio regolare, non un servizio di intenti. Una volta che il servizio intento è finito, finisce. Un servizio può avviare un thread in background che manterrà la connessione del socket Web finché non lo si uccide esplicitamente; oppure il sistema operativo recupera la memoria del servizio (in cui è necessario riavviarlo).