/**
 * Adds an input stream to the request.
 *
 * @param key         the key name for the new param.
 * @param stream      the input stream to add.
 * @param name        the name of the stream.
 * @param contentType the content type of the file, eg. application/json
 * @param length      the content length, if set can support upload progress
 */
public void put(String key, InputStream stream, String name, String contentType, long length) {
    if (key != null && stream != null) {
        streamParams.put(key, new StreamWrapper(stream, name, contentType, length));
    }
}


    // Add stream params
    for (ConcurrentHashMap.Entry<String, StreamWrapper> entry : streamParams.entrySet()) {
        StreamWrapper stream = entry.getValue();
        if (stream.inputStream != null) {
            entity.addPart(entry.getKey(), stream.name, stream.inputStream,
                    stream.contentType, stream.length);
        }
    }


public static class StreamWrapper {
    public InputStream inputStream;
    public String name;
    public String contentType;
    public long length;

    public StreamWrapper(InputStream inputStream, String name, String contentType) {
        this(inputStream, name, contentType, 0);
    }

    public StreamWrapper(InputStream inputStream, String name, String contentType, long length) {
        this.inputStream = inputStream;
        this.name = name;
        this.contentType = contentType;
        this.length = length;
    }
}

public void addPart(final String key, File file, String type) {
    if (type == null) {
        type = APPLICATION_OCTET_STREAM;
    }
    // fileParts.add(new FilePart(key, file, type));

    FileInputStream inputStream = null;
    try
    {
        inputStream = new FileInputStream(file);
    }
    catch (FileNotFoundException e)
    {
        Log.w(LOG_TAG, "Cannot find file exception", e);
    }

    if (inputStream == null)
    {
        return;
    }

    inputStreamParts.add(new InputStreamPart(key, file.getName(), inputStream, type, file.length()));
}

public void addPart(String key, String streamName, InputStream inputStream, String type, long length)
        throws IOException {
    if (type == null) {
        type = APPLICATION_OCTET_STREAM;
    }

    if (length > 0)
    {
        inputStreamParts.add(new InputStreamPart(key, streamName, inputStream, type, length));
        return;
    }


    out.write(boundaryLine);

    // Headers
    out.write(createContentDisposition(key, streamName));
    out.write(createContentType(type));
    out.write(TRANSFER_ENCODING_BINARY);
    out.write(CR_LF);

    // Stream (file)
    final byte[] tmp = new byte[4096];
    int l;
    while ((l = inputStream.read(tmp)) != -1) {
        out.write(tmp, 0, l);
    }

    out.write(CR_LF);
    out.flush();
    try {
        inputStream.close();
    } catch (final IOException e) {
        // Not important, just log it
        Log.w(LOG_TAG, "Cannot close input stream", e);
    }
}

private byte[] createContentType(String type) {
    String result = "Content-Type: " + type + "\r\n";
    return result.getBytes();
}

private byte[] createContentDisposition(final String key) {
    return ("Content-Disposition: form-data; name=\"" + key + "\"\r\n")
            .getBytes();
}

private byte[] createContentDisposition(final String key, final String fileName) {
    return ("Content-Disposition: form-data; name=\"" + key + "\"; filename=\"" + fileName + "\"\r\n")
            .getBytes();
}

private void updateProgress(int count) {
    bytesWritten += count;
    progressHandler.sendProgressMessage(bytesWritten, totalSize);
}

private class InputStreamPart
{
    public InputStream inputStream;
    public byte[] header;
    public long length;

    public InputStreamPart(String key, String streamName, InputStream inputStream, String type, long length)
    {
         header = createHeader(key, streamName, type);
         this.inputStream = inputStream;
         this.length = length;
    }

    private byte[] createHeader(String key, String streamName, String type) {
        ByteArrayOutputStream headerStream = new ByteArrayOutputStream();
        try {
            headerStream.write(boundaryLine);

            // Headers
            headerStream.write(createContentDisposition(key, streamName));
            headerStream.write(createContentType(type));
            headerStream.write(TRANSFER_ENCODING_BINARY);
            headerStream.write(CR_LF);
        } catch (IOException e) {
            // Can't happen on ByteArrayOutputStream
            Log.e(LOG_TAG, "createHeader ByteArrayOutputStream exception", e);
        }
        return headerStream.toByteArray();
    }

    public long getTotalLength() {
        long streamLength = this.length + CR_LF.length;
        return header.length + streamLength;
    }

    public void writeTo(OutputStream out) throws IOException {
        out.write(header);
        updateProgress(header.length);

        final byte[] tmp = new byte[4096];
        int l;
        while ((l = inputStream.read(tmp)) != -1) {
            out.write(tmp, 0, l);
            updateProgress(l);
        }
        out.write(CR_LF);
        updateProgress(CR_LF.length);
        out.flush();
        try {
            inputStream.close();
        } catch (final IOException e) {
            // Not important, just log it
            Log.w(LOG_TAG, "Cannot close input stream", e);
        }
    }
}

// The following methods are from the HttpEntity interface

@Override
public long getContentLength() {
    long contentLen = out.size();

    for (InputStreamPart inputStreamPart : inputStreamParts) {
        long len = inputStreamPart.getTotalLength();
        if (len < 0) {
            return -1; // Should normally not happen
        }
        contentLen += len;
    }
    contentLen += boundaryEnd.length;
    return contentLen;
}

@Override
public Header getContentType() {
    return new BasicHeader("Content-Type", "multipart/form-data; boundary=" + boundary);
}

@Override
public boolean isChunked() {
    return false;
}

public void setIsRepeatable(boolean isRepeatable) {
    this.isRepeatable = isRepeatable;
}

@Override
public boolean isRepeatable() {
    return isRepeatable;
}

@Override
public boolean isStreaming() {
    return false;
}

@Override
public void writeTo(final OutputStream outstream) throws IOException {
    bytesWritten = 0;
    totalSize = (int) getContentLength();
    out.writeTo(outstream);
    updateProgress(out.size());

    for (InputStreamPart inputStreamPart : inputStreamParts) {
        inputStreamPart.writeTo(outstream);
    }
    outstream.write(boundaryEnd);
    updateProgress(boundaryEnd.length);
}

@Override
public Header getContentEncoding() {
    return null;
}

@Override
public void consumeContent() throws IOException, UnsupportedOperationException {
    if (isStreaming()) {
        throw new UnsupportedOperationException(
                "Streaming entity does not implement #consumeContent()");
    }
}

@Override
public InputStream getContent() throws IOException, UnsupportedOperationException {
    throw new UnsupportedOperationException(
            "getContent() is not supported. Use writeTo() instead.");
}