Couple of fixes, one is very important:

Noor Dawod · Noor Dawod · commit d7d7e8162537 · 2015-01-04T18:54:56.000+01:00
1) When uploading many requests using JSON streamer, the reusable StringBuffer would have been emptied; a fix is no
w enclosed

2) Added a feature request: Let the user decide whether to embed "_elapsed" field, and even customize its name, or disable it completely.
diff --git a/library/src/main/java/com/loopj/android/http/JsonStreamerEntity.java b/library/src/main/java/com/loopj/android/http/JsonStreamerEntity.java
@@ -18,6 +18,7 @@
 
 package com.loopj.android.http;
 
+import android.text.TextUtils;
 import android.util.Log;
 
 import org.apache.http.Header;
@@ -51,11 +52,6 @@ public class JsonStreamerEntity implements HttpEntity {
     // Buffer used for reading from input streams.
     private final byte[] buffer = new byte[BUFFER_SIZE];
 
-    // Reusable StringBuilder used by escape() method.
-    // Its size is just initial, if more space is needed, the system will
-    // automatically enlarge the buffer.
-    private static final StringBuilder BUILDER = new StringBuilder(128);
-
     private static final byte[] JSON_TRUE = "true".getBytes();
     private static final byte[] JSON_FALSE = "false".getBytes();
     private static final byte[] JSON_NULL = "null".getBytes();
@@ -80,11 +76,14 @@ public class JsonStreamerEntity implements HttpEntity {
     // Whether to use gzip compression while uploading
     private final Header contentEncoding;
 
+    private final String elapsedField;
+
     private final ResponseHandlerInterface progressHandler;
 
-    public JsonStreamerEntity(ResponseHandlerInterface progressHandler, boolean useGZipCompression) {
+    public JsonStreamerEntity(ResponseHandlerInterface progressHandler, boolean useGZipCompression, String elapsedField) {
         this.progressHandler = progressHandler;
         this.contentEncoding = useGZipCompression ? HEADER_GZIP_ENCODING : null;
+        this.elapsedField = elapsedField;
     }
 
     /**
@@ -157,69 +156,86 @@ public void writeTo(final OutputStream out) throws IOException {
         // Keys used by the HashMaps.
         Set<String> keys = jsonParams.keySet();
 
+        int keysCount = keys.size();
+        int keysProcessed = -1;
         boolean isFileWrapper;
 
         // Go over all keys and handle each's value.
         for (String key : keys) {
-            // Evaluate the value (which cannot be null).
-            Object value = jsonParams.get(key);
+            // Indicate that this key has been processed.
+            keysProcessed++;
 
-            // Bail out prematurely if value's null.
-            if (value == null) {
-                continue;
-            }
+            try {
+                // Evaluate the value (which cannot be null).
+                Object value = jsonParams.get(key);
 
-            // Write the JSON object's key.
-            os.write(escape(key));
-            os.write(':');
+                // Bail out prematurely if value's null.
+                if (value == null) {
+                    continue;
+                }
+
+                // Write the JSON object's key.
+                os.write(escape(key));
+                os.write(':');
 
-            // Check if this is a FileWrapper.
-            isFileWrapper = value instanceof RequestParams.FileWrapper;
+                // Check if this is a FileWrapper.
+                isFileWrapper = value instanceof RequestParams.FileWrapper;
 
-            // If a file should be uploaded.
-            if (isFileWrapper || value instanceof RequestParams.StreamWrapper) {
-                // All uploads are sent as an object containing the file's details.
-                os.write('{');
+                // If a file should be uploaded.
+                if (isFileWrapper || value instanceof RequestParams.StreamWrapper) {
+                    // All uploads are sent as an object containing the file's details.
+                    os.write('{');
 
-                // Determine how to handle this entry.
-                if (isFileWrapper) {
-                    writeToFromFile(os, (RequestParams.FileWrapper) value);
+                    // Determine how to handle this entry.
+                    if (isFileWrapper) {
+                        writeToFromFile(os, (RequestParams.FileWrapper) value);
+                    } else {
+                        writeToFromStream(os, (RequestParams.StreamWrapper) value);
+                    }
+
+                    // End the file's object and prepare for next one.
+                    os.write('}');
+                } else if (value instanceof JsonValueInterface) {
+                    os.write(((JsonValueInterface) value).getEscapedJsonValue());
+                } else if (value instanceof org.json.JSONObject) {
+                    os.write(((org.json.JSONObject) value).toString().getBytes());
+                } else if (value instanceof org.json.JSONArray) {
+                    os.write(((org.json.JSONArray) value).toString().getBytes());
+                } else if (value instanceof Boolean) {
+                    os.write((Boolean) value ? JSON_TRUE : JSON_FALSE);
+                } else if (value instanceof Long) {
+                    os.write((((Number) value).longValue() + "").getBytes());
+                } else if (value instanceof Double) {
+                    os.write((((Number) value).doubleValue() + "").getBytes());
+                } else if (value instanceof Float) {
+                    os.write((((Number) value).floatValue() + "").getBytes());
+                } else if (value instanceof Integer) {
+                    os.write((((Number) value).intValue() + "").getBytes());
                 } else {
-                    writeToFromStream(os, (RequestParams.StreamWrapper) value);
+                    os.write(escape(value.toString()));
+                }
+            } finally {
+                // Separate each K:V with a comma, except the last one.
+                if (!TextUtils.isEmpty(elapsedField) || keysProcessed < keysCount) {
+                    os.write(',');
                 }
-
-                // End the file's object and prepare for next one.
-                os.write('}');
-            } else if (value instanceof JsonValueInterface) {
-                os.write(((JsonValueInterface) value).getEscapedJsonValue());
-            } else if (value instanceof org.json.JSONObject) {
-                os.write(((org.json.JSONObject) value).toString().getBytes());
-            } else if (value instanceof org.json.JSONArray) {
-                os.write(((org.json.JSONArray) value).toString().getBytes());
-            } else if (value instanceof Boolean) {
-                os.write((Boolean) value ? JSON_TRUE : JSON_FALSE);
-            } else if (value instanceof Long) {
-                os.write((((Number) value).longValue() + "").getBytes());
-            } else if (value instanceof Double) {
-                os.write((((Number) value).doubleValue() + "").getBytes());
-            } else if (value instanceof Float) {
-                os.write((((Number) value).floatValue() + "").getBytes());
-            } else if (value instanceof Integer) {
-                os.write((((Number) value).intValue() + "").getBytes());
-            } else {
-                os.write(escape(value.toString()));
             }
-
-            os.write(',');
         }
 
+        // Calculate how many milliseconds it took to upload the contents.
+        long elapsedTime = System.currentTimeMillis() - now;
+
         // Include the elapsed time taken to upload everything.
         // This might be useful for somebody, but it serves us well since
         // there will almost always be a ',' as the last sent character.
-        os.write(STREAM_ELAPSED);
-        os.write(':');
-        long elapsedTime = System.currentTimeMillis() - now;
-        os.write((elapsedTime + "}").getBytes());
+        if (!TextUtils.isEmpty(elapsedField)) {
+            os.write(STREAM_ELAPSED);
+            os.write(':');
+            os.write((elapsedTime + "").getBytes());
+        }
+
+        // Close the JSON object.
+        os.write('}');
 
         Log.i(LOG_TAG, "Uploaded JSON in " + Math.floor(elapsedTime / 1000) + " seconds");
 
@@ -321,60 +337,57 @@ static byte[] escape(String string) {
             return JSON_NULL;
         }
 
+        // Create a string builder to generate the escaped string.
+        StringBuilder sb = new StringBuilder(128);
+
         // Surround with quotations.
-        BUILDER.append('"');
+        sb.append('"');
 
         int length = string.length(), pos = -1;
         while (++pos < length) {
             char ch = string.charAt(pos);
             switch (ch) {
                 case '"':
-                    BUILDER.append("\\\"");
+                    sb.append("\\\"");
                     break;
                 case '\\':
-                    BUILDER.append("\\\\");
+                    sb.append("\\\\");
                     break;
                 case '\b':
-                    BUILDER.append("\\b");
+                    sb.append("\\b");
                     break;
                 case '\f':
-                    BUILDER.append("\\f");
+                    sb.append("\\f");
                     break;
                 case '\n':
-                    BUILDER.append("\\n");
+                    sb.append("\\n");
                     break;
                 case '\r':
-                    BUILDER.append("\\r");
+                    sb.append("\\r");
                     break;
                 case '\t':
-                    BUILDER.append("\\t");
+                    sb.append("\\t");
                     break;
                 default:
                     // Reference: http://www.unicode.org/versions/Unicode5.1.0/
                     if ((ch >= '\u0000' && ch <= '\u001F') || (ch >= '\u007F' && ch <= '\u009F') || (ch >= '\u2000' && ch <= '\u20FF')) {
                         String intString = Integer.toHexString(ch);
-                        BUILDER.append("\\u");
+                        sb.append("\\u");
                         int intLength = 4 - intString.length();
                         for (int zero = 0; zero < intLength; zero++) {
-                            BUILDER.append('0');
+                            sb.append('0');
                         }
-                        BUILDER.append(intString.toUpperCase(Locale.US));
+                        sb.append(intString.toUpperCase(Locale.US));
                     } else {
-                        BUILDER.append(ch);
+                        sb.append(ch);
                     }
                     break;
             }
         }
 
         // Surround with quotations.
-        BUILDER.append('"');
-
-        try {
-            return BUILDER.toString().getBytes();
-        } finally {
-            // Empty the String buffer.
-            // This is 20-30% faster than instantiating a new object.
-            BUILDER.setLength(0);
-        }
+        sb.append('"');
+
+        return sb.toString().getBytes();
     }
 }
diff --git a/library/src/main/java/com/loopj/android/http/RequestParams.java b/library/src/main/java/com/loopj/android/http/RequestParams.java
@@ -99,6 +99,7 @@ public class RequestParams implements Serializable {
     protected final static String LOG_TAG = "RequestParams";
     protected boolean isRepeatable;
     protected boolean useJsonStreamer;
+    protected String elapsedFieldInJsonStreamer = "_elapsed";
     protected boolean autoCloseInputStreams;
     protected final ConcurrentHashMap<String, String> urlParams = new ConcurrentHashMap<String, String>();
     protected final ConcurrentHashMap<String, StreamWrapper> streamParams = new ConcurrentHashMap<String, StreamWrapper>();
@@ -412,12 +413,25 @@ public String toString() {
         return result.toString();
     }
 
-    public void setHttpEntityIsRepeatable(boolean isRepeatable) {
-        this.isRepeatable = isRepeatable;
+    public void setHttpEntityIsRepeatable(boolean flag) {
+        this.isRepeatable = flag;
     }
 
-    public void setUseJsonStreamer(boolean useJsonStreamer) {
-        this.useJsonStreamer = useJsonStreamer;
+    public void setUseJsonStreamer(boolean flag) {
+        this.useJsonStreamer = flag;
+    }
+
+    /**
+     * Sets an additional field when upload a JSON object through the streamer
+     * to hold the time, in milliseconds, it took to upload the payload. By
+     * default, this field is set to "_elapsed".
+     *
+     * To disable this feature, call this method with null as the field value.
+     *
+     * @param value field name to add elapsed time, or null to disable
+     */
+    public void setElapsedFieldInJsonStreamer(String value) {
+        this.elapsedFieldInJsonStreamer = value;
     }
 
     /**
@@ -449,8 +463,10 @@ public HttpEntity getEntity(ResponseHandlerInterface progressHandler) throws IOE
     }
 
     private HttpEntity createJsonStreamerEntity(ResponseHandlerInterface progressHandler) throws IOException {
-        JsonStreamerEntity entity = new JsonStreamerEntity(progressHandler,
-                !fileParams.isEmpty() || !streamParams.isEmpty());
+        JsonStreamerEntity entity = new JsonStreamerEntity(
+            progressHandler,
+            !fileParams.isEmpty() || !streamParams.isEmpty(),
+            elapsedFieldInJsonStreamer);
 
         // Add string params
         for (ConcurrentHashMap.Entry<String, String> entry : urlParams.entrySet()) {
