Upload an Image Using Google Volley

Upload an image using Google Volley

I have an example to upload images by Google Volley. Take a look:

package net.colaborativa.exampleapp.api;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.VolleyLog;
import com.android.volley.toolbox.HttpHeaderParser;

public class PhotoMultipartRequest<T> extends Request<T> {

private static final String FILE_PART_NAME = "file";

private MultipartEntityBuilder mBuilder = MultipartEntityBuilder.create();
private final Response.Listener<T> mListener;
private final File mImageFile;
protected Map<String, String> headers;

public PhotoMultipartRequest(String url, ErrorListener errorListener, Listener<T> listener, File imageFile){
    super(Method.POST, url, errorListener);

    mListener = listener;
    mImageFile = imageFile;

    buildMultipartEntity();
}

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
    Map<String, String> headers = super.getHeaders();

    if (headers == null
            || headers.equals(Collections.emptyMap())) {
        headers = new HashMap<String, String>();
    }

    headers.put("Accept", "application/json");

    return headers;
}

private void buildMultipartEntity(){
    mBuilder.addBinaryBody(FILE_PART_NAME, mImageFile, ContentType.create("image/jpeg"), mImageFile.getName());
    mBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
    mBuilder.setLaxMode().setBoundary("xx").setCharset(Charset.forName("UTF-8"));
}

@Override
public String getBodyContentType(){
    String contentTypeHeader = mBuilder.build().getContentType().getValue();
    return contentTypeHeader;
}

@Override
public byte[] getBody() throws AuthFailureError{
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try {
        mBuilder.build().writeTo(bos);
    } catch (IOException e) {
        VolleyLog.e("IOException writing to ByteArrayOutputStream bos, building the multipart request.");
    }

    return bos.toByteArray();
}

@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
    T result = null;
    return Response.success(result, HttpHeaderParser.parseCacheHeaders(response));
}

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

And you can use it like this:

RequestQueue mQueue = Volley.newRequestQueue(context);
PhotoMultipartRequest imageUploadReq = new PhotoMultipartRequest(url, ErrorListener, Listener, imageFile);
mQueue.add(imageUploadReq);

I hope these codes will inspire you.

How to upload Image on server using Volley?

You should have to understand the concept to use of volley library and image uploads. Here are some other useful links for image upload and use of volley library.

volley library

Image upload using multipart

Note: I have also tested your tutorial.code are ok. Please check your image path properly. If possible then use their php code on any hosted web server. and check their json response and cross check your parameter which you have passed with server script's parameters..

How to do upload image with Volley library?

i am not much familier with volley, but give a try to the following code

//JSON Request

public MySampleImageUpload() { 
    JSONRequestResponse mResponse = new  
    JSONRequestResponse(mContext);

    Bundle parms = new Bundle();
    parms.putString("key_meail", "rojesh@demo.com");
    parms.setFile("key_url", image_path);

    mResponse.getResponse("sample_upload_data_url", REQUEST_CODE, this,
        parms);
}

// In SetFile & getResponse code

package com.fartogram.utils;

import java.io.File;

import org.json.JSONObject;

import android.content.Context;
import android.os.Bundle;

import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.examples.toolbox.MultipartRequest;
import com.android.volley.examples.toolbox.MyVolley;
import com.android.volley.toolbox.JsonObjectRequest;

public class JSONRequestResponse {

    public JSONRequestResponse(Context cntx) {
        mContext = cntx;
    }

    private final Context mContext;
    private int reqCode;
    private IParseListener listner;

    private boolean isFile = false;
    private String file_path = "", key = "";

    public void getResponse(String url, final int requestCode,
            IParseListener mParseListener) {
        getResponse(url, requestCode, mParseListener, null);
    }

    public void getResponse(String url, final int requestCode,
            IParseListener mParseListener, Bundle params) {
        this.listner = mParseListener;
        this.reqCode = requestCode;

        Response.Listener<JSONObject> sListener = new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                if (listner != null) {
                    listner.SuccessResponse(response, reqCode);
                }
            }
        };

        Response.ErrorListener eListener = new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                if (listner != null) {
                    listner.ErrorResponse(error, reqCode);
                }
            }
        };

        if (!isFile) {
            JsonObjectRequest jsObjRequest = new JsonObjectRequest(
                Request.Method.GET, url, null, sListener, 

eListener);
            MyVolley.getRequestQueue().add(jsObjRequest);
        } else {
                if (file_path != null) {
                    File mFile = new File(file_path);
                    MultipartRequest multipartRequest = 
    new MultipartRequest(url,eListener, sListener, key, mFile, params);
                MyVolley.getRequestQueue().add(multipartRequest);
            } 
        }
    }

    public boolean isFile() {
        return isFile;
    }

    public void setFile(String param, String path) {
        if (path != null && param != null) {
            key = param;
            file_path = path;
            this.isFile = true;
        }
    }

}

If it works for you mark it as right :)

How to upload image using volley with header token android

see below code I think there is problem

 @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        Map<String, String> params = new HashMap<String, String>();
        params.put("Content-Type", "application/json; charset=UTF-8");
        params.put("Authorization", "bearer  " + token);
        return params;
    }

please comment below line

        params.put("Content-Type", "application/json; charset=UTF-8");

This will help you

Uploading image to server using volley with multi-part data in body of post request

I was able to achieve this using retrofit 2, here's the code.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == 100 && resultCode == RESULT_OK && data != null) {

        //getting the image Uri
        Uri imageUri = data.getData();
        try {
            //getting bitmap object from uri
            Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), imageUri);

            //displaying selected image to imageview
            logo.setImageBitmap(bitmap);

            //calling the method uploadBitmap to upload image
            loading.setVisibility(View.VISIBLE);
            ///uploadBitmap(bitmap);

            File file = new File(getRealPathFromUri(this, imageUri));
            uploadImageFile(file);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public static String getRealPathFromUri(Context context, Uri contentUri) {
    Cursor cursor = null;
    try {
        String[] proj = { MediaStore.Images.Media.DATA };
        cursor = context.getContentResolver().query(contentUri, proj, null, null, null);
        int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
        cursor.moveToFirst();
        return cursor.getString(column_index);
    } finally {
        if (cursor != null) {
            cursor.close();
        }
    }
}

private void uploadImageFile(File file) throws IOException {

    file  = new Compressor(this).compressToFile(file);
    RequestBody requestFile = RequestBody.create(MediaType.parse("image/*"), file);
    // MultipartBody.Part is used to send also the actual filename
    MultipartBody.Part body = MultipartBody.Part.createFormData("avatar", file.getName(), requestFile);

    ApiConfig getResponse = AppConfig.getRetrofit().create(ApiConfig.class);
    Call<ServerResponse> call = getResponse.uploadFile("Bearer "+jsonToken, body);
    call.enqueue(new Callback< ServerResponse >() {
        @Override
        public void onResponse(@NonNull Call < ServerResponse > call, @NonNull retrofit2.Response<ServerResponse> response) {
            ServerResponse serverResponse = response.body();

            if (serverResponse.getData() != null) {
                Log.e(TAG, "Response is "+ serverResponse.getData());
               loading.setVisibility(View.GONE);
                Toast.makeText(ProfileSettings.this, "Avatar updated", Toast.LENGTH_SHORT).show();
            } else {
                Log.e("Response", String.valueOf(serverResponse));
            }
        }

        @Override
        public void onFailure(Call < ServerResponse > call, Throwable t) {
            Log.e(TAG, t.getMessage());
        }
    });
       // Log.e(TAG, "request is "+call.request().body()+" and "+call.request().headers());
    }

---

Related Topics