Usługi Android WebSocket nawiązywanie wielu połączeń

Question

Utworzono usługę sieci Web. ale utrzymanie połączenia wielokrotnego

Po prostu chcę, aby aplikacja wykonała jedno połączenie, chyba że połączenie sieciowe spadnie, a następnie wykonaj inne. Ale w tej chwili tworzy jedno połączenie, jeśli naciśniesz przycisk home na telefonie. i wrócić do aplikacji, spowoduje to kolejne połączenie.

Dzięki za pomoc dla facetów.

onCreate ... mojego główną działalność

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

Oczywisty

<!-- 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, miałem podobny problem.

Nie używaj intentService. Po prostu skorzystaj z usługi. Ponieważ po wykonaniu usługi intentService zakończy się samo.

Po zmianie do Serwisu, co można zrobić, jest użycie logiczną, aby sprawdzić, czy usługa została uruchomiona tak:

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; 
      } 
     } 
.... 

To znaczy, ta usługa rozpocznie się tylko raz. dopóki nie zabijesz go ręcznie.

to zadziałało dla mnie, spróbuj i daj mi znać.

Answer 2

Spróbuj filtrowanie działań w metodzie onReceive - coś jak if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction()))

Answer 3

Stało się to dlatego, Po powrocie do app onCreate będzie zadzwonić po raz drugi i to dokonać innego połączenia do gniazda. tak można proste nie rozpocząć kolejną usługę, jeśli IntentService nadal działa, coś takiego:

onCreate ... z główną działalność

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

metody aby sprawdzić, czy usługa jest uruchomiona

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

Powinieneś używać usługi regularnej, a nie usługi intencyjnej. Po zakończeniu zamierzonej usługi kończy się. Usługa może uruchomić wątek w tle, który będzie utrzymywał połączenie z gniazdem sieciowym, dopóki nie zostanie jawnie zabity; lub system operacyjny odzyskuje pamięć usługi (w której należy ją ponownie uruchomić).