异步任务，BufferedReader

Question

我有一个BufferedReader，当我尝试读取它时，它只是挂起，并没有做任何事情，我是这样做的吗？我在AsyncTask中使用这个。

• 编辑：我已经连接到了Wi-Fi平板电脑，以连接到我的电脑这是对172.20.104.203广播端口5334，线程开始时，我所看到的，但没有之后。

这里我的代码：

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

• 编辑 我都正确的权限或任何东西，我是一个的AsyncTask外这样它完美地工作，移动它因为我不想在主线程中使用它。

- 编辑，这里是完整的代码。

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

我猜测是，当你写出来的命令“GETPOS”底层的BufferedWriter没有实际发送的数据出来就行了（你应该用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(); 
    } 
} 

}