Working POST Multipart Request with Volley Using Latest API

In Android development, sending multipart requests, such as uploading files and text data, is a common task. While HttpEntity is no longer available in newer API versions, there are still ways to achieve multipart requests using Volley.

Creating a Basic Multipart Request

To create a multipart request, we can extend Volley's Request class like so:

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;

import java.util.Map;

class MultipartRequest extends Request {
    // Listener for request response
    private final Response.Listener mListener;
    // Listener for request error
    private final Response.ErrorListener mErrorListener;
    // Request headers
    private final Map mHeaders;
    // Multipart mime type (e.g., "multipart/form-data; boundary=XXX")
    private final String mMimeType;
    // Request body as multipart
    private final byte[] mMultipartBody;

    // Constructor
    public MultipartRequest(String url, Map headers, String mimeType, byte[] multipartBody,
                            Response.Listener listener, Response.ErrorListener errorListener) {
        super(Method.POST, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
        this.mHeaders = headers;
        this.mMimeType = mimeType;
        this.mMultipartBody = multipartBody;
    }

    // Getters and setters

    // Override getHeaders() if you need to add custom headers
    @Override
    public Map getHeaders() throws AuthFailureError {
        return (mHeaders != null) ? mHeaders : super.getHeaders();
    }

    // Override getBodyContentType() to set the correct mime type for the multipart request
    @Override
    public String getBodyContentType() {
        return mMimeType;
    }

    // Override getBody() to return the multipart body
    @Override
    public byte[] getBody() throws AuthFailureError {
        return mMultipartBody;
    }

    // Override parseNetworkResponse() to parse the response as a NetworkResponse
    @Override
    protected Response parseNetworkResponse(NetworkResponse response) {
        try {
            return Response.success(
                    response,
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

    // Delivering response and error
    @Override
    protected void deliverResponse(NetworkResponse response) {
        mListener.onResponse(response);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }
}

Building the Multipart Body

To build the multipart body, we can use the following steps:

byte[] multipartBody = new byte[0];
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(bos);
try {
    // Text data
    buildTextPart(dos, "name", "John Doe");
    buildTextPart(dos, "email", "[email protected]");

    // Image data
    Bitmap imageBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.my_image);
    buildImagePart(dos, "image", imageBitmap);

} catch (IOException e) {
    e.printStackTrace();
}
multipartBody = bos.toByteArray();

Including the Multipart Body in the Request

Once the multipart body is built, we can include it in our MultipartRequest instance like so:

MultipartRequest request = new MultipartRequest(
        "my_url",
        null, // Headers
        "multipart/form-data",
        multipartBody,
        new Response.Listener() {
            @Override
            public void onResponse(NetworkResponse response) {
                // Handle response
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                // Handle error
            }
        });

Adding Text Data to the Request

In addition to image data, you can also include text data in your request:

private void buildTextPart(DataOutputStream dataOutputStream, String name, String value) throws IOException {
    dataOutputStream.writeBytes(twoHyphens   boundary   lineEnd);
    dataOutputStream.writeBytes("Content-Disposition: form-data; name=\""   name   "\""   lineEnd);
    dataOutputStream.writeBytes(lineEnd);
    dataOutputStream.writeBytes(value);
    dataOutputStream.writeBytes(lineEnd);
}

Replace twoHyphens, boundary, and lineEnd with appropriate values from your code.

Complete Code Sample

The following code sample shows a complete modular implementation of a VolleyMultipartRequest class:

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class VolleyMultipartRequest extends Request {
    private final Response.Listener mListener;
    private final Response.ErrorListener mErrorListener;
    private final Map mHeaders;
    private final String mMimeType;
    private final byte[] mMultipartBody;

    public VolleyMultipartRequest(int method, String url, Response.Listener listener,
                                  Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
        this.mHeaders = null;
        this.mMimeType = null;
        this.mMultipartBody = null;
    }

    public VolleyMultipartRequest(String url, Map headers, String mimeType, byte[] multipartBody,
                                  Response.Listener listener, Response.ErrorListener errorListener) {
        super(Method.POST, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
        this.mHeaders = headers;
        this.mMimeType = mimeType;
        this.mMultipartBody = multipartBody;
    }

    @Override
    public Map getHeaders() throws AuthFailureError {
        return (mHeaders != null) ? mHeaders : super.getHeaders();
    }

    @Override
    public String getBodyContentType() {
        return mMimeType;
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        return mMultipartBody;
    }

    @Override
    protected Response parseNetworkResponse(NetworkResponse response) {
        try {
            return Response.success(
                    response,
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(NetworkResponse response) {
        mListener.onResponse(response);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }

    public static Map createMultipartRequestParts(Map params, Map data) {
        Map multipartParams = new HashMap();
        for (Map.Entry entry : params.entrySet()) {
            multipartParams.put(entry.getKey(), new DataPart(entry.getValue()));
        }
        for (Map.Entry entry : data.entrySet()) {
            multipartParams.put(entry.getKey(), entry.getValue());
        }
        return multipartParams;
    }

    public static byte[] createMultipartBody(Map data, String boundary) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        for (Map.Entry entry : data.entrySet()) {
            buildTextPart(dos, entry.getKey(), entry.getValue().getContentType(), entry.getValue().getFileName(), entry.getValue().getData());
        }