read logcat logs in nonblocking mode with end timeout

src/main/java/org/acra/collector/LogCatCollector.java

@@ -97,28 +97,19 @@ public String collectLogCat(@NonNull ACRAConfiguration config, @Nullable String
         commandLine.addAll(logcatArgumentsList);
 
         try {
-            final Process process = Runtime.getRuntime().exec(commandLine.toArray(new String[commandLine.size()]));
+            final Process process =  new ProcessBuilder().command(commandLine).redirectErrorStream(true).start();
 
             if (ACRA.DEV_LOGGING) ACRA.log.d(LOG_TAG, "Retrieving logcat output...");
 
-            // Dump stderr to null
-            new Thread(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        IOUtils.streamToString(process.getErrorStream());
-                    } catch (IOException ignored) {
-                    }
-                }
-            }).start();
 
             final String finalMyPidStr = myPidStr;
-            logcatBuf.add(IOUtils.streamToString(process.getInputStream(), new Predicate<String>() {
+            logcatBuf.add(IOUtils.streamToStringAsync(process.getInputStream(), new Predicate<String>() {
                 @Override
                 public boolean apply(String s) {
                     return finalMyPidStr == null || s.contains(finalMyPidStr);
                 }
-            }));
+            }, tailCount));
+            process.destroy();
 
         } catch (IOException e) {
             ACRA.log.e(LOG_TAG, "LogCatCollector.collectLogCat could not retrieve data.", e);

src/main/java/org/acra/util/IOUtils.java

@@ -45,6 +45,7 @@ public boolean apply(String s) {
         }
     };
     private static final int NO_LIMIT = -1;
+	private static final int READ_TIMEOUT = 3000;
 
     private IOUtils() {
     }
@@ -128,4 +129,36 @@ public static String streamToString(@NonNull InputStream input, Predicate<String
             safeClose(reader);
         }
     }
+
+	/**
+     * Reads an InputStream into a string in an async way
+     *
+     * @param input  the stream
+     * @param filter should return false for lines which should be excluded
+     * @param limit the maximum number of lines to read (the last x lines are kept)
+     * @return the read string
+     * @throws IOException
+     */
+    @NonNull
+    public static String streamToStringAsync(@NonNull InputStream input, Predicate<String> filter, int limit) throws IOException {
+        final BufferedReader reader = new BufferedReader(new InputStreamReader(input), ACRAConstants.DEFAULT_BUFFER_SIZE_IN_BYTES);
+        final NonblockingBufferedReader nonBlockingReader = new NonblockingBufferedReader(reader);
+        try {
+            String line;
+            final List<String> buffer = limit == NO_LIMIT ? new LinkedList<String>() : new BoundedLinkedList<String>(limit);
+            long end = System.currentTimeMillis() + READ_TIMEOUT;
+            while ((System.currentTimeMillis() < end)) {
+                try {
+                    if ((line = nonBlockingReader.readLine()) != null) {
+                        if (filter.apply(line)) {
+                            buffer.add(line);
+                        }
+                    }
+                } catch (InterruptedException e) {}
+            }
+            return TextUtils.join("\n", buffer);
+        } finally {
+            nonBlockingReader.close();
+        }
+    }
 }

src/main/java/org/acra/util/NonblockingBufferedReader.java

@@ -0,0 +1,52 @@
+package org.acra.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author C-Romeo
+ * @since 4.9.0
+ */
+public class NonblockingBufferedReader {
+    private final BlockingQueue<String> lines = new LinkedBlockingQueue<String>();
+    private boolean closed = false;
+    private Thread backgroundReaderThread = null;
+
+    public NonblockingBufferedReader(final BufferedReader bufferedReader) {
+        backgroundReaderThread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    while (!Thread.interrupted()) {
+                        String line = bufferedReader.readLine();
+                        if (line == null) {
+                            break;
+                        }
+                        lines.add(line);
+                    }
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                } finally {
+                    closed = true;
+                    IOUtils.safeClose(bufferedReader);
+                }
+            }
+        });
+        backgroundReaderThread.setDaemon(true);
+        backgroundReaderThread.start();
+    }
+
+    public String readLine() throws InterruptedException {
+        return closed && lines.isEmpty() ? null : lines.poll(500L, TimeUnit.MILLISECONDS);
+    }
+
+    public void close() {
+        if (backgroundReaderThread != null) {
+            backgroundReaderThread.interrupt();
+            backgroundReaderThread = null;
+        }
+    }
+}