Uploading a large file in multipart using OkHttp

Question

What are my options for uploading a single large file (more specifically, to s3) in multipart in Android using OKhttp?

Answer 1

Get OkHttp 2.1, and use MultipartBuilder.addFormDataPart() which takes the filename as a parameter.

       /**
         * Upload Image
         *
         * @param memberId
         * @param sourceImageFile
         * @return
         */
        public static JSONObject uploadImage(String memberId, String sourceImageFile) {
    
            try {
                File sourceFile = new File(sourceImageFile);
    
                Log.d(TAG, "File...::::" + sourceFile + " : " + sourceFile.exists());
             //Determining the media type        
             final MediaType MEDIA_TYPE = sourceImageFile.endsWith("png") ? 

                MediaType.parse("image/png") : MediaType.parse("image/jpeg");
                
    
                RequestBody requestBody = new MultipartBuilder()
                        .type(MultipartBuilder.FORM)
                        .addFormDataPart("member_id", memberId)
                        .addFormDataPart("file", "profile.png", RequestBody.create(MEDIA_TYPE, sourceFile))
                        .build();
    
                Request request = new Request.Builder()
                        .url(URL_UPLOAD_IMAGE)
                        .post(requestBody)
                        .build();
    
                OkHttpClient client = new OkHttpClient();
                Response response = client.newCall(request).execute();
                return new JSONObject(response.body().string());
    
            } catch (UnknownHostException | UnsupportedEncodingException e) {
                Log.e(TAG, "Error: " + e.getLocalizedMessage());
            } catch (Exception e) {
                Log.e(TAG, "Other Error: " + e.getLocalizedMessage());
            }
            return null;
        }

#Edited for okhttp3:

compile 'com.squareup.okhttp3:okhttp:3.4.1'

RequestBody replaced by:

RequestBody requestBody = new MultipartBody.Builder()
                    .setType(MultipartBody.FORM)
                    .addFormDataPart("uploaded_file", filename, RequestBody.create(MEDIA_TYPE_PNG, sourceFile))
                    .addFormDataPart("result", "my_image")
                    .build();

#Uploaded Demo on GITHUB: ##I have added my answer for Multiple Image Upload :)

Answer 2

From the OkHttp Recipes page, this code uploads an image to Imgur:

private static final String IMGUR_CLIENT_ID = "...";
private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");

private final OkHttpClient client = new OkHttpClient();

public void run() throws Exception {
  // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
  RequestBody requestBody = new MultipartBuilder()
      .type(MultipartBuilder.FORM)
      .addPart(
          Headers.of("Content-Disposition", "form-data; name=\"title\""),
          RequestBody.create(null, "Square Logo"))
      .addPart(
          Headers.of("Content-Disposition", "form-data; name=\"image\""),
          RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png")))
      .build();

  Request request = new Request.Builder()
      .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)
      .url("https://api.imgur.com/3/image")
      .post(requestBody)
      .build();

  Response response = client.newCall(request).execute();
  if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

  System.out.println(response.body().string());
}

You'll need to adapt this to S3, but the classes you need should be the same.

Answer 3

For okhttp 4.* use the MultipartBody.Builder:

fun postMultipart(url: String, text: String, imagePath: String, imageFileName: String): okhttp3.Response? {
    val file = File(imagePath)
    val fileRequestBody = file.asRequestBody("image/jpeg".toMediaType())
    val requestBody = MultipartBody.Builder()
        .addFormDataPart("text", text)
        .addFormDataPart("image", imageFileName, fileRequestBody)
        .build()

    val request = getRequestBuilder(url)
        .post(requestBody)
        .build()

    val client = OkHttpClient()
    client.newCall(request).execute().use { response ->
        return response
    }
}

Answer 4

for okhttp 2.6.0 {

    try {
        File file = new File(Environment.getExternalStorageDirectory().getPath()+"/xxx/share/" + "ic_launcher.png");
        String contentType = file.toURL().openConnection().getContentType();
        RequestBody fileBody = RequestBody.create(MediaType.parse(contentType), file);

        RequestBody requestBody = new MultipartBuilder()
                .type(MultipartBuilder.FORM)
                .addFormDataPart("fileUploadType","1")
                .addFormDataPart("miniType",contentType)
                .addFormDataPart("ext",file.getAbsolutePath().substring(file.getAbsolutePath().lastIndexOf(".")))
                .addFormDataPart("fileTypeName","img")
                .addFormDataPart("Filedata","ss.png",fileBody)
                .build();
        Request request = new Request.Builder()
                .url(Contains.MULTIPARTY_POST)
                .post(requestBody)
                .build();
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Request request, IOException e) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        tvGetNews.setText("upload fail");
                    }
                });
            }

            @Override
            public void onResponse(Response response) throws IOException {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        tvGetNews.setText("upload success");
                    }
                });
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }

}

Answer 5

In Android you usally part from an Uri. The problem when using large files is that you easily run into OutOfMemoryError if you try to read the full stream to a byte array (everything in memory) or you end up creating useless files with Uri stream. This is because RequestBody doesn't support creation from Stream (because sometimes OkHttp needs to read it many times, if you get a 30X redirect for instance) or Uri (because OkHttp is not an Android library).

But OkHttp provides the library Okio, with convenient classes emulating Streams (Source and Sink) and more convenient internal usage.

So, to create a BodyRequest form an Uri avoiding any OutOfMemoryError due to large files create it this way:

private static final MediaType MULTIPART_FOR_DATA = MediaType.parse("multipart/form-data");

private @NotNull RequestBody getFilePart(Uri largeFileUri) {

        return new RequestBody() {
            @Override
            public MediaType contentType() {
                return MULTIPART_FOR_DATA;
            }

            @Override
            public void writeTo(@NotNull BufferedSink sink) throws IOException {
                try (Source source = Okio.source(context.getContentResolver().openInputStream(mediaUri))) {
                    sink.writeAll(source);
                }
            }
        };
    }

Thank you to everyone posting and commenting in the folowing GitHub thread https://github.com/square/okhttp/issues/3585