How to Upload Files Onto Server Java

The previous tutorials guided y'all through diverse apply cases of Retrofit and showed you opportunities to enhance the app with Retrofit's congenital-in functionality. This tutorial will show you how to upload a file to a backend server using the second major release of Retrofit, namely Retrofit two.

Retrofit Series Overview

• Retrofit
• Requests
• Responses
• Converters
• Error Handling
• Logging
• Calladapters
• Pagination
• File Upload & Download
• Authentication
• Caching
• Testing & Mocking
• Java Basics for Retrofit

File Upload with Retrofit 1.ten

We've already published a tutorial on how to upload files using Retrofit 1.x. If you're using Retrofit 1, delight follow the link.

Using Retrofit 2? This tutorial is for you and delight read on :)

Upload Files With Retrofit 2

This tutorial is intentionally separated from the already published tutorial on how to upload files with Retrofit v1, because the internal changes from Retrofit one to Retrofit 2 are profound and y'all demand to empathise the way Retrofit 2 handles file uploads.

Before we dive deeper into the file upload topic with Retrofit ii, let's shortly recap the previously used functionality in v1. Retrofit 1 used a class called TypedFile for file uploads to a server. This course has been removed from Retrofit 2. Further, Retrofit 2 now leverages the OkHttp library for any network operation and, as a result, OkHttp's classes for use cases similar file uploads.

Using Retrofit two, you need to use either OkHttp's RequestBody or MultipartBody.Part classes and encapsulate your file into a request body. Permit's have a look at the interface definition for file uploads.

          public interface FileUploadService {       @Multipart     @POST("upload")     Telephone call<ResponseBody> upload(         @Part("description") RequestBody clarification,         @Part MultipartBody.Part file     ); }                  

Let me explain each part of the definition above. Kickoff, you need to declare the unabridged telephone call as @Multipart request. Permit's continue with the annotation for description. The description is just a string value wrapped inside a RequestBody instance. Secondly, there's another @Office inside the request: the actual file. We employ the MultipartBody.Role class that allows us to send the bodily file name besides the binary file data with the request. You'll come across how to create the file object correctly within the following section.

Android Customer Code

At this point, yous've defined the necessary service interface for Retrofit. Now you tin movement on and touch the bodily file upload. We'll use the ServiceGenerator course which generates a service client. We've introduced the ServiceGenerator form in the creating a sustainable Android client tutorial earlier in this series.

The post-obit code snippet shows the uploadFile(Uri fileUri) method taking the file'due south uri every bit a parameter. If yous're starting an intent to choose a file, you'll return within the onActivityResult() method of Android'southward lifecycle. In this method, yous can get the file's uri and that's exactly what you'll use to upload the file within the uploadFile method.

          private void uploadFile(Uri fileUri) {       // create upload service customer     FileUploadService service =             ServiceGenerator.createService(FileUploadService.form);      // https://github.com/iPaulPro/aFileChooser/blob/master/aFileChooser/src/com/ipaulpro/afilechooser/utils/FileUtils.coffee     // use the FileUtils to go the bodily file by uri     File file = FileUtils.getFile(this, fileUri);      // create RequestBody example from file     RequestBody requestFile =             RequestBody.create(                          MediaType.parse(getContentResolver().getType(fileUri)),                          file              );      // MultipartBody.Part is used to ship also the actual file name     MultipartBody.Part body =             MultipartBody.Part.createFormData("picture", file.getName(), requestFile);      // add some other part within the multipart request     String descriptionString = "howdy, this is clarification speaking";     RequestBody clarification =             RequestBody.create(                     okhttp3.MultipartBody.FORM, descriptionString);      // finally, execute the request     Telephone call<ResponseBody> call = service.upload(description, trunk);     phone call.enqueue(new Callback<ResponseBody>() {         @Override         public void onResponse(Call<ResponseBody> call,                                Response<ResponseBody> response) {             Log.5("Upload", "success");         }          @Override         public void onFailure(Call<ResponseBody> call, Throwable t) {             Log.e("Upload error:", t.getMessage());         }     }); }                  

The snippet higher up shows you the code to initialize the payload (body and clarification) and how to employ the file upload service. As already mentioned, the RequestBody class is from OkHttp and used for the description. Its .create() method requires two parameters: first, the media type, and second, the bodily data. The media blazon for the description can simply be OkHttp's constant for multipart requests: okhttp3.MultipartBody.FORM. The media type for the file should ideally be the actual content-type. For example, a PNG image should take paradigm/png. Our code snippet above figures out the content type with the getContentResolver().getType(fileUri) telephone call and so parses the result into OkHttp's media type with MediaType.parse().

Besides the description, you'll add the file wrapped into a MultipartBody.Function instance. That'south what you need to use to appropriately upload files from client-side. Further, you can add the original file name within the createFormData() method and reuse information technology on your backend.

Remember the Content-Type

Please proceed an eye on Retrofit's content blazon. If yous intercept the underlying OkHttp client and change the content type to application/json, your server might accept problems with the deserialization process. Make sure you're not defining the header indicating you're sending JSON data, simply multipart/form-data.

Next: Upload Files with Progress Updates

If y'all upload files in the foreground and they are not pocket-size, you might want to inform the user on your deportment. Ideally, you would display progress updates how much you've uploaded already. Nosotros've some other tutorial on how to upload files with progress updates.

Exemplary Hapi Server for File Uploads

If you already have your backend project, y'all can lean on the instance code below. We utilise a simple hapi server with a Mail route available at /upload. Additionally, we tell hapi to don't parse the incoming asking, considering we use a Node.js library called multiparty for the payload parsing.

Within the callback of multiparty's parsing role, we're logging each field to show its output.

          method: 'POST',   path: '/upload',   config: {       payload: {         maxBytes: 209715200,         output: 'stream',         parse: false     },     handler: part(request, reply) {         var multiparty = require('multiparty');         var form = new multiparty.Form();         form.parse(request.payload, function(err, fields, files) {             panel.log(err);             console.log(fields);             console.log(files);              render respond(util.inspect({fields: fields, files: files}));         });     } }                  

Android client expects a return type of String, we're sending the received information every bit response. Of course your response will and should look different :)

Below you tin run into the output of a successful request and payload parsing on server-side. The first cypher is the err object. Afterward, you can meet the fields which is but the clarification as part of the request. And last but not least, the file is available within the picture field. Hither you run into our previously defined names on client side. 20160312_095248.jpg is passed as the original name and the bodily field name is picture. For farther processing, admission the uploaded image at path'southward location.

Server Log for Parsed Payload

          cypher   { description: [ 'hello, this is description speaking' ] } { movie:    [ { fieldName: 'picture',        originalFilename: '20160312_095248.jpg',        path: '/var/folders/rq/q_m4_21j3lqf1lw48fqttx_80000gn/T/X_sxX6LDUMBcuUcUGDMBKc2T.jpg',        headers: [Object],        size: 39369 } ] }                  

Outlook

File uploads are an essential feature within upwardly-to-date apps and you can integrate this feature within your app using Retrofit. This tutorial guided you lot through the necessary steps to upload a file from your Android device to your backend server.

What to await inside the next mail service on Retrofit? Next week you'll acquire all about how to get back logging within Retrofit 2. Stay tuned, information technology will be a good shot!

---

Still Have Questions? Get Our Retrofit Book!

All modern Android apps need to do network requests. Retrofit offers yous an extremely convenient way of creating and managing network requests. From asynchronous execution on a background thread, to automatic conversion of server responses to Java objects, Retrofit does almost everything for you. Once you've a deep understanding of Retrofit, writing complex requests (e.one thousand., OAuth authentication) will be washed in a few minutes.

Invest fourth dimension to fully understand Retrofit's principles. It'll pay off multiple times in the future! Our book offers you a fast and easy way to get a full overview over Retrofit. You'll acquire how to create effective Rest clients on Android in every detail.

Boost your productivity and savour working with complex APIs.

milesaropporry.blogspot.com

Source: https://futurestud.io/tutorials/retrofit-2-how-to-upload-files-to-server

Share this post