I am using retrofit 2 multipart for high quality Image upload (around 12 MB image). It works fine if I uses a Mobile Phone. But when I use Tablet it does not work. Can anyone tell me, what am I doing wrong here?
Here is my code:
public interface ApiDataService {
#Multipart
#POST("API Path Here")
Call<UploadImageResponse> Upload(#Header(Constants.KEY_AUTHORIZATION) String authorization,
#Part MultipartBody.Part file,
#Part("userId") RequestBody userId);
}
public class RetrofitInstance {
private static Retrofit retrofit = null;
public static Retrofit getInstance(){
OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(100, TimeUnit.SECONDS)
.readTimeout(100,TimeUnit.SECONDS).build();
if(retrofit == null){
retrofit = new Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
Then I am using following method to Upload Image on server:
public void callUploadImageApi(String token, String fileName, String userId){
ApiDataService apiDataService = RetrofitInstance.getInstance().create(ApiDataService.class);
token = "Bearer "+ token;
File path = Environment.getExternalStorageDirectory();
File dir = new File(path.getAbsolutePath() + "/MyApplication/"+ fileName);
// create RequestBody instance from file
RequestBody requestFile =
RequestBody.create(
MediaType.parse("image/*"),
dir
);
// MultipartBody.Part is used to send also the actual file name
MultipartBody.Part body =
MultipartBody.Part.createFormData("picture", dir.getName(), requestFile);
// add another part within the multipart request
RequestBody userIdString =
RequestBody.create(
okhttp3.MultipartBody.FORM, userId);
Call<UploadImageResponse> call = apiDataService.Upload(token, body, userIdString);
call.enqueue(new Callback<UploadImageResponse>() {
#Override
public void onResponse(Call<UploadImageResponse> call, Response<UploadImageResponse> response) {
if (response.body() != null) {
//success code here
}
}
#Override
public void onFailure(Call<UploadImageResponse> call, Throwable t) {
//failure code here
}
});
}
Thanks in advance for helping me...
I am new to android .
I want to upload image as form data using Retrofit Post method.
I am using com.squareup.retrofit2:retrofit:2.3.0
This is my request body.
**Make interface like this add "MultipartBody.Part" in request and set your image path as post method and you can upload image using retrofit use this networkclient class to create retrofit instance **
public class NetworkClient {
private static final String BASE_URL = "";
private static Retrofit retrofit;
public static Retrofit getRetrofitClient(Context context) {
if (retrofit == null) {
OkHttpClient okHttpClient = new OkHttpClient.Builder()
.build();
retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
public interface UploadAPIs {
#Multipart
#POST("/upload")
Call<ResponseBody> uploadImage(#Part MultipartBody.Part file, #Part("name") RequestBody requestBody);
}
private void uploadToServer(String filePath) {
Retrofit retrofit = NetworkClient.getRetrofitClient(this);
UploadAPIs uploadAPIs = retrofit.create(UploadAPIs.class);
//Create a file object using file path
File file = new File(filePath);
// Create a request body with file and image media type
RequestBody fileReqBody = RequestBody.create(MediaType.parse("image/*"), file);
// Create MultipartBody.Part using file request-body,file name and part name
MultipartBody.Part part = MultipartBody.Part.createFormData("upload", file.getName(), fileReqBody);
//Create request body with text description and text media type
RequestBody description = RequestBody.create(MediaType.parse("text/plain"), "image-type");
//
Call call = uploadAPIs.uploadImage(part, description);
call.enqueue(new Callback() {
#Override
public void onResponse(Call call, Response response) {
}
#Override
public void onFailure(Call call, Throwable t) {
}
});
}
Try this
#Multipart
#POST(Global.updateProfilePicture)
Call<YOUR_RESPONSE_MODEL> updatePicture(#Header("Authorization") String authorization, #PartMap Map<String, RequestBody> params);
And API call should be like this
public void updatePic(String senderID, String receiverID, String type, File photo) {
mProgressDialog.show();
final Map<String, RequestBody> map = new HashMap<>();
try {
RequestBody fileBody = RequestBody.create(MediaType.parse("multipart/form-data"), photo);
map.put("image\"; filename=\"" + photo.getName() + "\"", fileBody);
} catch (Exception e) {
e.printStackTrace();
}
map.put("sender_id", RequestBody.create(MediaType.parse("multipart/form-data"), senderID));
map.put("receiver_id", RequestBody.create(MediaType.parse("multipart/form-data"), receiverID));
map.put("type", RequestBody.create(MediaType.parse("multipart/form-data"), type));
Call<YOUR_RESPONSE_MODEL> call = mApiInterface.updatePicture(ACCESS_TOKEN, map);
call.enqueue(new Callback<YOUR_RESPONSE_MODEL>() {
#Override
public void onResponse(#NonNull Call<YOUR_RESPONSE_MODEL> call, #NonNull Response<YOUR_RESPONSE_MODEL> response) {
if (mContext != null) {
mProgressDialog.dismiss();
// Dismiss Dialog
}
}
#Override
public void onFailure(#NonNull Call<YOUR_RESPONSE_MODEL> call, #NonNull Throwable t) {
if (mContext != null) {
mProgressDialog.dismiss();
}
}
});
}
I got output by doing request as following
UploadAPI Interface
`
#Multipart
#Headers({"TOKEN:XXXX"})
#POST("/api/messages/image")Call<ImageResult>uploadImage(#Part("sender_id")RequestBody sender_id,#Part("receiver_id")RequestBody receiver_id,#Part("type")RequestBody type,#Part MultipartBody.Part image);`
And Following is Method Code, I tried
`
private void uploadToServer(String filePath)
{
Retrofit retrofit = NetworkClient.getRetrofitClient(this, sendImageMsgURL);
UploadAPIs uploadAPIs = retrofit.create(UploadAPIs.class);
File file = new File(filePath);
MultipartBody.Part requestImage = null;
RequestBody requestFile = RequestBody.create(MediaType.parse("mutlipart/form-
data"),file);
requestImage = MultipartBody.Part.createFormData("image", file.getName(), requestFile);
RequestBody sender_id = RequestBody.create(MediaType.parse("multipart/form-data"),
currentID);
RequestBody receiver_id = RequestBody.create(MediaType.parse("multipart/form-data"),
otherID);
RequestBody type = RequestBody.create(MediaType.parse("multipart/form-data"), "image");
Call<ImageResult> call = uploadAPIs.uploadImage(sender_id, receiver_id, type,
requestImage);
call.enqueue(new Callback<ImageResult>()
{
private Call<ImageResult> call;
private Response<ImageResult> response;
#Override
public void onResponse(Call<ImageResult> call, Response<ImageResult> response)
{
this.call = call;
this.response = response;
}
#Override
public void onFailure(Call call, Throwable t) {
Log.d("Error--------- :", t.getMessage());
}
});
}`
I am using Retrofit to upload files to a server. It works correctly sometimes, but occasionally (and quite often), it gives me response 400 (Bad request) to the same request. Is it a known issue or what could be the problem?
This is whole code for upload:
public static void uploadFile(String authString,
Uri fileUri,
Context context,
MVPCallback<ResponseBody> mvpCallback) {
FileUploadService service =
ServiceGenerator.createService(FileUploadService.class, authString);
String filePath = FacadeMedia.getPath(context, fileUri);
if (filePath != null) {
File uploadFile = new File(filePath);
RequestBody requestFile = RequestBody.create(
MediaType.parse(context.getContentResolver().getType(fileUri)),
uploadFile);
MultipartBody.Part body =
MultipartBody.Part.createFormData("file", uploadFile.getName(), requestFile);
String content_disposition = "file; filename=\"" + uploadFile.getName() + "\"";
Call<ResponseBody> call = service.upload(body, content_disposition);
call.enqueue(new Callback<ResponseBody>() {
#Override
public void onResponse(Call<ResponseBody> call,
Response<ResponseBody> response) {
if(response.isSuccessful()){
mvpCallback.onSuccess(response.body());
}else {
mvpCallback.onError(new Throwable(response.errorBody().toString()));
}
}
#Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
mvpCallback.onError(t);
}
});
}
}
public interface FileUploadService {
#Multipart
#POST(HttpFactory.UPLOAD_FILE_URL)
Call<ResponseBody> upload(
#Part MultipartBody.Part file,
#Header("Content-Disposition") String content_disposition
);
}
public class ServiceGenerator {
private static Retrofit retrofit;
private static Retrofit.Builder builder =
new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create());
private static OkHttpClient.Builder httpClient =
new OkHttpClient.Builder();
public static <S> S createService(Class<S> serviceClass, String authString) {
httpClient.addInterceptor(chain -> {
Request request = chain.request()
.newBuilder()
.addHeader("Authorization", " Basic "+authString).build();
return chain.proceed(request);
});
retrofit = builder.client(httpClient.build()).build();
return retrofit.create(serviceClass);
}
}
EDIT:
This is the errorBody message:
E/Bad request:: <html>
<head><title>400 Bad Request</title></head>
<body bgcolor="white">
<center><h1>400 Bad Request</h1></center>
<hr><center>cloudflare-nginx</center>
</body>
</html>
So I fixed this my reinitializing OkHttpClient every ew request. Probably it has some old data in it. If anyone can elaborate on this, would be great.
I'm trying to upload a videofile from my app.
Here's what I've got so far:
public class Download extends Application {
public interface upload {
#Multipart
#POST("new")
Call<Response> send(#Part("myFile") RequestBody file);
}
public void uploadFile(File xfile) {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://192.168.0.3")
.addConverterFactory(GsonConverterFactory.create())
.build();
RequestBody file = RequestBody.create(MediaType.parse("video/*"), xfile);
upload xUpload = retrofit.create(upload.class);
Call<Response> call = xUpload.send(file);
try {
Response result = call.execute().body();
}
catch (IOException e)
{
Log.d("TEST3", " didn't work ");
}
}
}
I get the following error retrofit2.Response' is not a valid response body type. Did you mean ResponseBody? for method upload.send any ideas
I've read up on the retrofit2 webpage and tried the main example they have for uploading a file but it didn't work for two reasons.
1. I couldn't find right ServiceGenerator
2. My file was found in the Gallery and I streamed its contents to a temporary file which I'm to upload, I can't access it directly from its URI... or can I with retrofit2?
i use to upload image from retrofit 2 like this,it worked correctly
File file = new File(image.getPath());
RequestBody mFile = RequestBody.create(MediaType.parse("image/*"), file);
MultipartBody.Part fileToUpload = MultipartBody.Part.createFormData("gallery", file.getName(), mFile);
RequestBody filename = RequestBody.create(MediaType.parse("text/plain"), id);
final NetworkCall networkCall=new NetworkCall(this);
Call<ResponseBody> call = networkCall.getRetrofit(false).uploadImage( filename, fileToUpload);
call.clone().enqueue(new Callback<ResponseBody>() {
#Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
}
#Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
}
});
here is my network call class:
public class NetworkCall {
Context context;
ProgressDialog progressDialog;
public NetworkCall(Context context){
this.context = context;
}
public IApi getRetrofit(boolean isShowLoading){
OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
httpClient.connectTimeout(0, TimeUnit.SECONDS).readTimeout(0,TimeUnit.SECONDS);
httpClient.addInterceptor(new Interceptor() {
#Override
public Response intercept(Chain chain) throws IOException {
Request original = chain.request();
Request request = original.newBuilder()
.header("Content_type","application/json")
.header("Accept", "application/json")
.method(original.method(), original.body())
.build();
return chain.proceed(request);
}
});
Gson gson = new GsonBuilder()
.setLenient()
.create();
OkHttpClient client = httpClient.build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.client(client)
.addConverterFactory(GsonConverterFactory.create(gson))
.build();
if (isShowLoading&&context instanceof BaseActivity)
showLoading();
// prepare call in Retrofit 2.0
IApi api = retrofit.create(IApi.class);
// Call<BaseResponce> call = api.callService(json);
//asynchronous call
// call.enqueue(this);
return api;
}
private void showLoading(){
try {
((BaseActivity)context).runOnUiThread(new Runnable() {
#Override
public void run() {
progressDialog = new ProgressDialog(context);
progressDialog.setMessage("Please wait...");
progressDialog.setCancelable(false);
progressDialog.show();
}
});
}catch (Exception e){
e.printStackTrace();
}
}
public void dismissLoading(){
try {
((BaseActivity)context).runOnUiThread(new Runnable() {
#Override
public void run() {
progressDialog.cancel();
progressDialog.dismiss();
}
});
}catch (Exception e){
e.printStackTrace();
}
}
}
i use this in IApi class
#Multipart
#POST("events/file_upload.json")
Call <ResponseBody> uploadImage(#Part("event_id") RequestBody id,#Part MultipartBody.Part part);
hope it helps
I'm trying to upload image on server using retrofit2 beta 3. In response i'm getting success but image is not getting uploaded on server. I dont know where's i'm making mistake.
and
Header Type is Content-Type: application/x-www-form-urlencoded
My Interface
#Multipart
#POST("/uploadFile")
Call<ResponseBody> upload(#PartMap Map<String, RequestBody> params);
and the method i used for uploading is
Method for uploading Image and data
private void uploadFile() {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Constants.BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
ApiInterface service =
retrofit.create(ApiInterface.class);
File file = new File(fileUri.getPath());
Log.e(TAG, "uploadFile: " + file.toString());
String fileName = "uploadFile\"; filename=\"" + file.getName();
final RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
final RequestBody empsno = RequestBody.create(MediaType.parse("text/plain"), strEmpsno);
final RequestBody storsno = RequestBody.create(MediaType.parse("text/plain"), strStoreSno);
final RequestBody strlr = RequestBody.create(MediaType.parse("text/plain"), strLrno);
final RequestBody strtecq = RequestBody.create(MediaType.parse("text/plain"), strRecqty);
final RequestBody strtecv = RequestBody.create(MediaType.parse("text/plain"), strRecvol);
final RequestBody strtecw = RequestBody.create(MediaType.parse("text/plain"), strRecwgt);
final RequestBody strdmg = RequestBody.create(MediaType.parse("text/plain"), strDamageqty);
final RequestBody strlus = RequestBody.create(MediaType.parse("text/plain"), strLooseqty);
final RequestBody strdd = RequestBody.create(MediaType.parse("text/plain"), strDeliverydate);
final RequestBody strdt = RequestBody.create(MediaType.parse("text/plain"), strDeliverytime);
final RequestBody strrem = RequestBody.create(MediaType.parse("text/plain"), strRemarks);
final RequestBody strrec = RequestBody.create(MediaType.parse("text/plain"), strReceivedby);
final RequestBody strip = RequestBody.create(MediaType.parse("text/plain"), strIpaddress);
Map<String, RequestBody> oJSONObject = new HashMap<>();
oJSONObject.put("empsno", empsno);
oJSONObject.put("storesno", storsno);
oJSONObject.put("lrSno", strlr);
oJSONObject.put("recQty", strtecq);
oJSONObject.put("recVol", strtecv);
oJSONObject.put("recWgt", strtecw);
oJSONObject.put("damageQty", strdmg);
oJSONObject.put("looseQty", strlus);
oJSONObject.put("deliveryDate", strdd);
oJSONObject.put("deliveryTime", strdt);
oJSONObject.put("remarks", strrem);
oJSONObject.put("receivedBy", strrec);
oJSONObject.put("ipAddress", strip);
Call<ResponseBody> call = service.upload(oJSONObject);
call.enqueue(new Callback<ResponseBody>() {
#Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
Log.e(TAG, "onResponse: " + response.isSuccessful());
if (response.isSuccessful()) {
Log.e(TAG, "onResponse: " + response.body());
}
}
#Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
Log.e(TAG, "onFailure: " + t.getLocalizedMessage());
}
});
}
in response response.isSuccessful()=true. My response is getting successful then where is my problem. Please help me to find the solution.
Other way i also tried but not getting success, same result in another way also
#Multipart
#POST("/uploadFile")
Call<Response> getDetails(#Part("empsno") RequestBody empsno,
#Part("storesno")RequestBody storesno,
#Part("lrSno")RequestBody lrSno,
#Part("recQty")RequestBody recQty,
#Part("recVol")RequestBody recVol,
#Part("recWgt")RequestBody recWgt,
#Part("damageQty")RequestBody damageQty,
#Part("looseQty")RequestBody looseQty,
#Part("deliveryDate")RequestBody deliveryDate,
#Part("deliveryTime")RequestBody deliveryTime,
#Part("uploadFile\"; filename=\"abc.jpg\" ") RequestBody part,
#Part("remarks")RequestBody remarks,
#Part("receivedBy")RequestBody receivedBy,
#Part("ipAddress") RequestBody ipAddress
and method i used here is
File file = new File(fileUri.getPath());
RequestBody requestFile = RequestBody.create(MediaType.parse("multipart/form-data"), file);
MultipartBody.Part body = MultipartBody.Part.createFormData("uploadFile", file.getName(), requestFile);
RequestBody empsno = RequestBody.create(MediaType.parse("text/plain"), strEmpsno);
RequestBody storsno = RequestBody.create(MediaType.parse("text/plain"), strStoreSno);
RequestBody strlr = RequestBody.create(MediaType.parse("text/plain"), strLrno);
RequestBody strtecq = RequestBody.create(MediaType.parse("text/plain"), strRecqty);
RequestBody strtecv = RequestBody.create(MediaType.parse("text/plain"), strRecvol);
RequestBody strtecw = RequestBody.create(MediaType.parse("text/plain"), strRecwgt);
RequestBody strdmg = RequestBody.create(MediaType.parse("text/plain"), strDamageqty);
RequestBody strlus = RequestBody.create(MediaType.parse("text/plain"), strLooseqty);
RequestBody strdd = RequestBody.create(MediaType.parse("text/plain"), strDeliverydate);
RequestBody strdt = RequestBody.create(MediaType.parse("text/plain"), strDeliverytime);
RequestBody strrem = RequestBody.create(MediaType.parse("text/plain"), strRemarks);
RequestBody strrec = RequestBody.create(MediaType.parse("text/plain"), strReceivedby);
RequestBody strip = RequestBody.create(MediaType.parse("text/plain"), strIpaddress);
ApixInterface xInterface = retrofit.create(AudexInterface.class);
Call<Response> podResponsecall = xInterface.getDetails(empsno, storsno, strlr, strtecq,
strtecv, strtecw, strdmg, strlus, strdd, strdt,
requestFile, strrem, strrec, strip);
podResponsecall.enqueue(new Callback<Response>() {
#Override
public void onResponse(Call<Response> call, Response<Response> response) {
Log.e(TAG, "onResponse: " + response.isSuccessful());
if (response.isSuccessful()) {
Toast.makeText(getApplicationContext(), "Successfully saved!!!", Toast.LENGTH_LONG);
Log.e(TAG, "onResponse: " + response.body().getResult());
uploadFile();
}
}
#Override
public void onFailure(Call<Response> call, Throwable t) {
Log.e(TAG, "onFailure: " + t.getLocalizedMessage());
}
});
By using this method also response is successful but image not getting upload on server.
Thanks in advance
my solution is that:
first step.
#Multipart
#POST("Work/SendPic.ashx")
Observable<ImgBean> uploadImg(#Part MultipartBody.Part file);
second step.
RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"),file);
MultipartBody.Part body =
MultipartBody.Part.createFormData("img", file.getName(), requestBody);
UploadImg uploadImg = BaseRetrofit.getInstance().create(UploadImg.class);
and then, it is working.
What i have observed is there is some bug in Okhttp which does not upload image. Handle it like this:
#Multipart
#POST("api/chats/upload_chat_image")
Call<UploadChatItemResponse> getImageLink(
#Header("Authorization") String token,
#Part("productid") RequestBody productid,
#Part("touserid") RequestBody touserid,
#Part("image\";filename=\"image.*\" ") RequestBody image);
Notice the last part. You can create #PartMap for remaining items. But don't do it for files. Also, the first image in last part should be the key server is expecting while last image should be as it is.
RequestBody uploadImage = RequestBody.create(MediaType.parse("image/png"), compressed_image);
RequestBody productId = RequestBody.create(MediaType.parse("text/plain"), product.getProductid() + "");
RequestBody userId = RequestBody.create(MediaType.parse("text/plain"), otherUserInfo.getUserid() + "");
Call<UploadChatItemResponse> uploadChatImage = RestClient.getInstance(getApplicationContext()).getRestService()
.getImageLink(PrefUtils.getToken(ChatActivity.this), productId, userId, uploadImage);
uploadChatImage.enqueue(new Callback<UploadChatItemResponse>() {
#Override
public void onResponse(Call<UploadChatItemResponse> call, Response<UploadChatItemResponse> response) {
if (response.body() != null && response.body().imageLink != null) {
sendMessage(response.body().imageLink, new ChatItem.ChatType(false, ChatItem.ChatType.CHAT_TYPE_IMAGE, ChatItem.ChatType.CHAT_SUBTYPE_NO_SUBTYPE));
sweetAlertDialog.dismiss();
compressed_image.delete();
} else {
Toast.makeText(ChatActivity.this, "An error has occurred", Toast.LENGTH_SHORT).show();
sweetAlertDialog.dismiss();
compressed_image.delete();
}
}
#Override
public void onFailure(Call<UploadChatItemResponse> call, Throwable t) {
Toast.makeText(ChatActivity.this, "An error has occurred", Toast.LENGTH_SHORT).show();
sweetAlertDialog.dismiss();
compressed_image.delete();
}
});
Notice the type I have used while creating RequestBody for image.
Edit:
This is RestClient.java.
public class RestClient extends ContextWrapper {
private static final String BASE_URL = "https://www.restapi.in";
private APIService apiService;
private static RestClient restClient;
private static OkHttpClient okHttpClient;
private static final int READ_TIMEOUT = 100 * 1000;
private static final int CONNECTION_TIMEOUT = 100 * 1000;
private static final int CACHE_SIZE = 4;
private static final String CERTIFICATE_DOMAIN = "www.restclient.in";
private static final String[] CERTIFICATE_SHA = {"sha256/dkjabkjabcbakjbakjsbcabcahkcbakcbakcbakh=",
"sha256/ckjdcndkjcnjcnajcnajskcnakjcnakjcnaksjcna=",
"sha256/cjkacakjcbajcbasjkcbacjcbakcbcbakjbcjkacb="};
private RestClient(Context context) {
super(context);
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(getOkHttpClient(context))
.addConverterFactory(GsonConverterFactory.create())
.build();
apiService = retrofit.create(APIService.class);
}
public static RestClient getInstance(Context context){
if(restClient==null)
restClient = new RestClient(context.getApplicationContext());
return restClient;
}
private static OkHttpClient getOkHttpClient(Context context){
if (okHttpClient == null) {
HttpLoggingInterceptor logger = new HttpLoggingInterceptor();
logger.setLevel(BuildConfig.DEBUG?HttpLoggingInterceptor.Level.HEADERS:HttpLoggingInterceptor.Level.NONE);
CertificatePinner.Builder certificatePinnerBuilder = new CertificatePinner.Builder();
for(String sha : CERTIFICATE_SHA)
certificatePinnerBuilder.add(CERTIFICATE_DOMAIN, sha);
okHttpClient = new OkHttpClient.Builder()
.cache(setCache(context))
.certificatePinner(certificatePinnerBuilder.build())
.retryOnConnectionFailure(false)
.readTimeout(READ_TIMEOUT, TimeUnit.MILLISECONDS)
.connectTimeout(CONNECTION_TIMEOUT, TimeUnit.MILLISECONDS)
.addInterceptor(new Interceptor() {
#Override
public okhttp3.Response intercept(Chain chain) throws IOException {
Request original = chain.request();
Request request = original.newBuilder()
.header("Content-type", "application/json")
.header("Accept", "application/json")
.method(original.method(), original.body())
.build();
return chain.proceed(request);
}
})
.addInterceptor(logger)
.build();
}
return okHttpClient;
}
private static Cache setCache(Context context) {
int cacheSize = CACHE_SIZE * 1024 * 1024;
return new Cache(new File(context.getCacheDir(), "http"), cacheSize);
}
public APIService getRestService(){
return apiService;
}
}
Just remove Header Type
#headers({Content-Type: application/x-www-form-urlencoded})