비동기 작업, BufferedReader

Question

BufferedReader를 읽으려고하면 그냥 멈추고 아무 것도하지 않습니다.이 작업을 수행하고 있습니까? 나는 이것을 AsyncTask에서 사용하고있다.

• 편집 : 내가는 Wi-Fi에 연결 태블릿, 이것은 스레드가 시작할 때, 내가 볼 수있는 포트 (5334)에 172.20.104.203에 방송, 아무것도하지만 그 후 내 컴퓨터에 연결합니다. 여기

내 코드 : 나는 모든 권리 권한 또는 아무것도, 나는 AsyncTask를 외부에서이 일을하고 그것을 완벽하게 작동, 그것을 이동 한

try { 
     final BufferedReader in = new BufferedReader(
     new InputStreamReader(socket.getInputStream()));  
     String line = null; 
     while ((line = in.readLine()) != null) { 
      final String msg; 
      msg = (line); 
      Log.d("DeviceActivity", msg); 
     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
     Log.e("ClientAcivtity: Exception", 
     String.valueOf(e)); 
    } 

• 편집 왜냐하면 나는 주 스레드에서 그것을 원하지 않았기 때문입니다.

- 은 전체 코드입니다.

public class NetworkTask extends AsyncTask<Void, byte[], Boolean> { 
     Socket nsocket; // Network Socket 
     InputStream nis; // Network Input Stream 
     OutputStream nos; // Network Output Stream 
     private Handler handler = new Handler(); 

     Boolean connected = false; 

     public static final int PORT = 5334; 
     public String SERVERIP = "172.20.104.203"; 

     Socket socket; 

     @Override 
     protected void onPreExecute() { 
      Log.i("AsyncTask", "onPreExecute"); 
      InetAddress serverAddr; 
      try { 
       serverAddr = InetAddress.getByName(SERVERIP); 
       socket = new Socket(serverAddr, PORT); 
       connected = true; 
      } catch (UnknownHostException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
       Log.e("ClientAcivtity: Exception", String.valueOf(e)); 
      } catch (IOException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
       Log.e("ClientAcivtity: Exception", String.valueOf(e)); 
      } 
     } 

     @Override 
     protected Boolean doInBackground(Void... params) { // This runs on a 
                  // different thread 
      boolean result = false; 

      try { 

       Log.d("ClientActivity", "C: Connecting..."); 
       if (socket != null) { 
        int cont = 1; 
        while (cont == 1) { 
         try { 
          Log.d("ClientActivity", "C: Sending command."); 
          PrintWriter out = new PrintWriter(
            new BufferedWriter(new OutputStreamWriter(
              socket.getOutputStream())), true); 
          // where you issue the commands 
          out.println("getPos"); 
          Log.d("ClientActivity", "C: Sent " + "getPos"); 

         } catch (Exception e) { 
          Log.e("ClientAcivtity: Exception", 
            String.valueOf(e)); 
         } 
         try { 
          final BufferedReader in = new BufferedReader(
            new InputStreamReader(
              socket.getInputStream())); 
          String line = null; 
          while ((line = in.readLine()) != null) { 
           final String msg; 
           msg = (line); 
           Log.d("DeviceActivity", msg); 
          } 
         } catch (Exception e) { 
          e.printStackTrace(); 
          Log.e("ClientAcivtity: Exception", 
            String.valueOf(e)); 
         } 
         cont--; 
        } 

        Log.d("ClientActivity", "C: Closed."); 
       } 
      } catch (Exception e) { 
       Log.e("ClientAcivtity: Exception", String.valueOf(e)); 
      } 

      return result; 
     } 

     @Override 
     protected void onProgressUpdate(byte[]... values) { 
      if (values.length > 0) { 
       Log.i("AsyncTask", "onProgressUpdate: " + values[0].length 
         + " bytes received."); 
      } 
     } 

     @Override 
     protected void onCancelled() { 
      Log.i("AsyncTask", "Cancelled."); 
     } 

     @Override 
     protected void onPostExecute(Boolean result) { 
      if (socket != null) { 
       if (connected) { 
        if (result) { 
         Log.i("AsyncTask", 
           "onPostExecute: Completed with an Error."); 
         try { 
          socket.close(); 
         } catch (IOException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
         } 
        } else { 
         Log.i("AsyncTask", "onPostExecute: Completed."); 
         try { 
          socket.close(); 
         } catch (IOException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
         } 
        } 
       } 
      } 
     } 
    } 

Answer 1

내 추측은 당신이 (기본 BufferedWriter가 실제로 행에 데이터를 전송하지 명령 "getPos"을 쓸 때 당신이해야 이것을 tcpdump/wireshark로 확인하십시오). 이 경우 서버는 명령을받지 못하기 때문에 readLine()에 응답하지 않습니다.이 주장을 확인하려면 out.println("getPos");

다음에 out.flush();을 추가하십시오. 실제로 tcpdump는 포럼의 모든 사용자에게 더 나은 대답을 줄 것입니다.

http://developer.android.com/reference/java/io/BufferedWriter.html

Answer 2

과 같이 그 일을보십시오 :

소켓에서 읽기

final BufferedReader in = new BufferedReader(new InputStreamReader(
                socket.getInputStream())); 
StringBuffer buf = new StringBuffer(); 
int i; 
while((i = in.read()) != -1){ 
    buf.append((char) i); 
} 

String data = buf.toString(); 

Answer 3

소켓이 실제로에 어떻게 상대방이 응답의 연결 위치 따라 매우 어려운 문제입니다.

다른 쪽이 매우 빠르면 읽기 루틴이 실제로 잘 작동하도록 충분한 데이터가있는 소켓을 제공 할 수 있습니다. 그러나 다른 종류의 지연이있는 경우 (작은 기본 시간 제한을 포함하여 읽기 루틴보다 느릴 필요가 있습니다) 상대방에 데이터가있을지라도 읽기가 실패합니다 - 너무 조금 느리게 도착합니다. 소켓에서.

필요에 따라 독자적인 최소 및 최대 타이머를 읽기 루틴으로 감쌀 수 있습니다.

자세한 정보를 제공해 주시면 문제를 더 잘 이해할 수 있습니다.

대부분의 경우 다른 쪽에서 데이터를 소켓에 푸시 할 수있는 최소 시간 제한을 설정해야하지만 실제로 데이터가 도착하기를 기다리는 데 걸릴 최대 시간이 필요할 수도 있습니다.

업데이트 :

첫 번째 모니터링 스레드를 시작할 수있는 실행 파일. 필요한 경우 루프에 monitoringCanRun을 사용하여 스레드를 인터럽트 할 수 있습니다. 그리고 monitoringThreadIsAlive은 스레드가 아직 실행 중인지 알기 위해 사용할 수 있습니다.

monitoringCanRun = true; 
    new Thread(new Runnable() { 
    public void run() { 
     monitoringThreadIsAlive = true; 
     performMonitoring(); 
     monitoringThreadIsAlive = false; 
    } 
    }).start(); 
} 

및 performMonitoring은 다음과 같습니다

public void performMonitoring() { 
while (monitoringCanRun) { 
    ... do your read in the while loop 
    ...you might like to insert some delay before trying again... 
    try { //we delay every partial read so we are not too fast for the other side 
    Thread.sleep(100); 
    } catch (InterruptedException e) { 
    // TODO Auto-generated catch block 
    e.printStackTrace(); 
    } 
} 

}