Android multipart image upload with HttpConnectionParams deprecated in new api

Question

I am using MultiPartRequester class for multipart image upload to server, but i found that some part is deprecated in this. for example HttpConnectionParams , getConnectionManager() etc. so anyone have new solution that is not deprecated with new API level for file upload?

I am using this code.

public class MultiPartRequester {
	private Map<String, String> map;
	private AsyncTaskCompleteListener mAsynclistener;
	private int serviceCode;
	private HttpClient httpclient;
	private Activity activity;
	private AsyncHttpRequest request;
	private static final String TAG = "MultiPartRequester";

	public MultiPartRequester(Activity activity, Map<String, String> map,
		int serviceCode, AsyncTaskCompleteListener asyncTaskCompleteListener) {
		this.map = map;
		this.serviceCode = serviceCode;
		this.activity = activity;
	}

	class AsyncHttpRequest extends AsyncTask<String, Void, String> {
		@Override
		protected String doInBackground(String... urls) {
			map.remove("url");
			try {
				HttpPost httppost = new HttpPost(urls[0]);
				httpclient = new DefaultHttpClient();
				HttpConnectionParams.setConnectionTimeout(
						httpclient.getParams(), 600000);
				MultipartEntityBuilder builder = MultipartEntityBuilder
						.create();
				for (String key : map.keySet()) {
					if (key.equalsIgnoreCase(AndyConstants.Params.PICTURE)) {
						File f = new File(map.get(key));
						builder.addBinaryBody(key, f,
								ContentType.MULTIPART_FORM_DATA, f.getName());
					} else {
						builder.addTextBody(key, map.get(key), ContentType
								.create("text/plain", MIME.UTF8_CHARSET));
					}
					AppLog.Log(TAG, key + "---->" + map.get(key));
				}
				httppost.setEntity(builder.build());
				ActivityManager manager = (ActivityManager) activity
						.getSystemService(Context.ACTIVITY_SERVICE);
				if (manager.getMemoryClass() < 25) {
					System.gc();
				}
				HttpResponse response = httpclient.execute(httppost);
				String responseBody = EntityUtils.toString(
						response.getEntity(), "UTF-8");
				reurn responseBody;
			} catch (Exception e) {
				e.printStackTrace();
			} catch (OutOfMemoryError oume) {
				System.gc();	
			} finally {
				if (httpclient != null)
					httpclient.getConnectionManager().shutdown();
			}
			return null;
		}

		@Override
		protected void onPostExecute(String response) {
			if (mAsynclistener != null) {
				mAsynclistener.onTaskCompleted(response, serviceCode);
			}
		}
	}
	public void cancelTask() {
		request.cancel(true);
		AppLog.Log(TAG, "task is canelled");
	}
}

Answer 1

this is FileUploadMultipartRequest class:

/**
 * Multipart request for sending files over http
 * also can return generic type of response data
 * @param <T> the type of data for http responses
 */
public class FileUploadMultipartRequest<T> extends BaseRequest<T>
{
    private static final MediaType JSON = MediaType.parse("application/json");
    private File[] files;
    private String jsonString;
    private RequestBody requestBody;

    public FileUploadMultipartRequest(String url, Map<String, String> headers, String jsonString, OnEmptyResponseListener listener, ErrorTypeListener errorListener, File... files)
    {
        super(Method.POST, url, headers, listener, new ErrorListenerImpl(errorListener));
        this.jsonString = jsonString;
        this.files = files;
    }

    public FileUploadMultipartRequest(String url, Map<String, String> headers, String jsonString, Type responseType, Response.Listener listener, ErrorTypeListener errorListener, File... files)
    {
        super(Method.POST, url, headers, responseType, listener, new ErrorListenerImpl(errorListener));
        this.jsonString = jsonString;
        this.files = files;
    }

    @Override
    public String getBodyContentType()
    {
        return buildMultipartEntity().contentType().toString();
    }

    @Override
    public byte[] getBody() throws AuthFailureError
    {
        Buffer buffer = new Buffer();
        try
        {
            buildMultipartEntity().writeTo(buffer);
        } catch (IOException e)
        {
            VolleyLog.e("IOException writing to ByteArrayOutputStream");
        }
        return buffer.readByteArray();
    }

    private RequestBody buildMultipartEntity()
    {

        if (requestBody == null)
        {
            MultipartBuilder multipartBuilder = new MultipartBuilder().type(MultipartBuilder.FORM);

            multipartBuilder.addPart(
                    Headers.of("Content-Disposition", "form-data; name=json-part"),
                    RequestBody.create(JSON, jsonString));

            for (File file : files)
            {
                String contentType = URLConnection.guessContentTypeFromName(file.getName());
                multipartBuilder.addFormDataPart("files-part", file.getName(),
                        RequestBody.create(MediaType.parse(contentType), file));
            }

            requestBody = multipartBuilder.build();
        }
        return requestBody;
    }

}

this is BaseRequest class:

/**
 * this a abstract request class for handling http http responses
 * note : all volley request should extend this class for http request
 *
 * @param <T> the type of data for http responses
 */
public abstract class BaseRequest<T> extends Request<T>
{
    private final Map<String, String> headers;

    /**
     * the type response that {@link com.android.volley.Response.Listener} should return
     */
    private Type responseType;

    /**
     * generic listener for successful http request
     */
    private Response.Listener<T> listener;

    /**
     * constructor for request that returns data type {@link T}
     *
     * @param method        http verb e.g. POST, GET & etc
     * @param url           request URL
     * @param headers       http headers
     * @param responseType  type of data that response should return
     * @param listener      event for successful request
     * @param errorListener event for failed request
     */
    public BaseRequest(int method, String url, Map<String, String> headers, Type responseType, Response.Listener listener, ErrorListenerImpl errorListener)
    {
        super(method, url, errorListener);
        this.headers = headers;
        this.responseType = responseType;
        //noinspection unchecked
        this.listener = listener;
    }

    /**
     * constructor for requests with no returning data
     *  @param method                  http verb e.g. POST, GET & etc
     * @param url                     request URL
     * @param headers                 http headers
     * @param onEmptyResponseListener event for successful request (but no data return)
     * @param errorListener           event for failed request
     */
    public BaseRequest(int method, String url, Map<String, String> headers, OnEmptyResponseListener onEmptyResponseListener, ErrorListenerImpl errorListener)
    {
        super(method, url, errorListener);
        this.headers = headers;
        //noinspection unchecked
        listener = new OnEmptyResponseImpl(onEmptyResponseListener);
    }

    protected Response<T> parseNetworkResponse(NetworkResponse response)
    {

        // if response type is null so just pass null to success event
        if (this.responseType == null && new String(response.data).isEmpty())
        {
            return Response.success(null, HttpHeaderParser.parseCacheHeaders(response));
        }

        // if response type is specified
        try
        {
            Gson gson = new Gson();
            String json = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
            // we use GSON to reflect response data to the generic type and pass to success event
            T parseObject = gson.fromJson(json, responseType);
            return Response.success(parseObject, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e)
        {
            return Response.error(new ParseError(e));
        } catch (JsonSyntaxException e)
        {
            return Response.error(new ParseError(e));
        }
    }


    @Override
    protected void deliverResponse(T response)
    {
        if (listener != null)
        {
            // call successful response event when listener not empty
            listener.onResponse(response);
        }
    }

    @Override
    protected void onFinish()
    {
        super.onFinish();
        listener = null;
    }

    /**
     * this class forward response event to {@link com.khosravi.mehrdadz.garagesale.Network.RequestType.BaseRequest.OnEmptyResponseListener}
     * when volley {@link com.android.volley.Response.Listener} is called
     */
    private static class OnEmptyResponseImpl implements Response.Listener
    {
        OnEmptyResponseListener onEmptyResponseListener;

        /**
         * @param onEmptyResponseListener interface for response with not data return
         */
        public OnEmptyResponseImpl(OnEmptyResponseListener onEmptyResponseListener)
        {
            this.onEmptyResponseListener = onEmptyResponseListener;
        }

        /**
         * we call {@link com.khosravi.mehrdadz.garagesale.Network.RequestType.BaseRequest.OnEmptyResponseImpl#onEmptyResponseListener}
         * when volley listener is class so no null object passed to the event
         *
         * @param response
         */
        @Override
        public void onResponse(Object response)
        {
            onEmptyResponseListener.OnEmptyResponse();
        }
    }

    /**
     * interface for http response with no returning data
     */
    public interface OnEmptyResponseListener
    {
        void OnEmptyResponse();
    }

    public Map<String, String> getHeaders() throws AuthFailureError
    {
        return this.headers != null ? this.headers : super.getHeaders();
    }
}

and this is GsonRequest class:

@SuppressWarnings("JavaDoc")
/**
 * Gson request that return generic type of response data
 * @param <T> the type of data for http responses
 */
public class GsonRequest<T> extends BaseRequest<T>
{
    protected static final String PROTOCOL_CHARSET = "utf-8";
    /**
     * Content type for request.
     */
    private static final String PROTOCOL_CONTENT_TYPE =
            String.format("application/json; charset=%s", PROTOCOL_CHARSET);

    /**
     * message body of http request
     */
    private final String requestBody;

    /**
     * Request return response object of Type {@link T}
     * @param url
     * @param headers
     * @param type
     * @param listener
     * @param errorListener
     */
    public GsonRequest(String url, Map<String, String> headers, Type type, Listener<T> listener, ErrorTypeListener errorListener)
    {
        super(Method.GET, url, headers, type, listener, new ErrorListenerImpl(errorListener));
        requestBody = null;
    }

    /**
     * Request return response object of Type {@link T}
     * @param url
     * @param headers
     * @param jsonObject json object to send with request
     * @param type
     * @param listener
     * @param errorListener
     */
    public GsonRequest(String url, Map<String, String> headers, JSONObject jsonObject, Type type, Listener<T> listener, ErrorTypeListener errorListener)
    {
        super(Method.POST, url, headers, type, listener, new ErrorListenerImpl(errorListener));
        this.requestBody = jsonObject == null ? null : jsonObject.toString();
    }

    /**
     * Request return empty response
     * @param url
     * @param headers
     * @param jsonObject json object to send with request
     * @param listener
     * @param errorListener
     */
    public GsonRequest(String url, Map<String, String> headers, JSONObject jsonObject, OnEmptyResponseListener listener, ErrorTypeListener errorListener)
    {
        super(Method.POST, url, headers, listener, new ErrorListenerImpl(errorListener));
        this.requestBody = jsonObject == null ? null : jsonObject.toString();
    }

    /**
     * Request return empty response
     * @param url
     * @param headers
     * @param listener
     * @param errorListener
     */
    public GsonRequest(String url, Map<String, String> headers, BaseRequest.OnEmptyResponseListener listener, ErrorTypeListener errorListener)
    {
        super(Method.GET, url, headers, listener, new ErrorListenerImpl(errorListener));
        requestBody = null;
    }


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

    @Override
    public byte[] getBody()
    {
        try
        {
            return requestBody == null ? null : requestBody.getBytes(PROTOCOL_CHARSET);
        } catch (UnsupportedEncodingException uee)
        {
            VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s",
                    requestBody, PROTOCOL_CHARSET);
            return null;
        }
    }
}

sample cod:

public class MyRequest
{
public MyRequest(Context context)
    {
        volleySingleton = VolleySingleton.getInstance(context);
    }
private static final String INSERT_NEW_PIC = "INSERT_NEW_PIC";
public void UploadNewPic(File[] Images, BaseRequest.OnEmptyResponseListener listener, ErrorTypeListener errorListener)
    {

        FileUploadMultipartRequest fileUploadMultipartRequest = new FileUploadMultipartRequest("url", null, null, listener, errorListener,Images);
        volleySingleton.addToRequestQueue(fileUploadMultipartRequest, INSERT_NEW_PIC);
    }
}

you can add more request to my request and call that anywhere. like this:

MyRequest myRequest;
private HashMap<FrameLayout,File> Images;

myRequest = new MyRequest(context);
Images = new HashMap<>();

myRequest.UploadNewPic(Images.values().toArray(new File[Images.values().size()]),  new BaseRequest.OnEmptyResponseListener()
                    {
                        @Override
                        public void OnEmptyResponse()
                        {
                            Toast.makeText(getApplicationContext(), "added pics successfully", Toast.LENGTH_LONG).show();
                            finish();
                        }
                    }, new ErrorTypeListener()
                    {
                        @Override
                        public void onError(ErrorType errorType)
                        {

                        }
                    });

server side cod (.net):

public class CustomMultipartFormDataStreamProvider : MultipartFormDataStreamProvider
    {
        public CustomMultipartFormDataStreamProvider(string path) : base(path) { }


        //below only allows images and pdf files to be uploaded.
        public override Stream GetStream(HttpContent parent, System.Net.Http.Headers.HttpContentHeaders headers)
        {

            // following line handles other form fields other than files.
            if (String.IsNullOrEmpty(headers.ContentDisposition.FileName)) return base.GetStream(parent, headers);

            // restrict what filetypes can be uploaded
            List<string> extensions = new List<string> { "png", "gif",
                "jpg", "jpeg", "tiff", "pdf", "tif", "bmp","doc","docx","ods","xls","odt","csv","txt","rtf" };
            var filename = headers.ContentDisposition.FileName.Replace("\"", string.Empty); // correct for chrome.

            //make sure it has an extension
            if (filename.IndexOf('.') < 0)
            {
                return Stream.Null;
            }

            //get the extension
            var extension = filename.Split('.').Last();

            //Return stream if match otherwise return null stream.
            return extensions.Contains(extension) ? base.GetStream(parent, headers) : Stream.Null;

        }

        public override string GetLocalFileName(System.Net.Http.Headers.HttpContentHeaders headers)
        {
            var name = !string.IsNullOrWhiteSpace(headers.ContentDisposition.FileName) ? headers.ContentDisposition.FileName : "NoName";
            name = name.Replace("\"", string.Empty);
            //name = (Guid.NewGuid()).ToString() +System.IO.Path.GetExtension(name); //this is here because Chrome submits files in quotation marks which get treated as part of the filename and get escaped

            name = Path.GetRandomFileName().Replace(".", string.Empty) + Path.GetExtension(name); //this is here because Chrome submits files in quotation marks which get treated as part of the filename and get escaped

            return name;
        }
    }

public class ImageRouteHandler :

IRouteHandler
{

    public IHttpHandler GetHttpHandler(RequestContext requestContext)
    {
        var filename = requestContext.RouteData.Values["filename"] as string;
        var section = requestContext.RouteData.Values["section"] as string;

        if (string.IsNullOrEmpty(filename) && string.IsNullOrEmpty(section))
        {
            // return a 404 HttpHandler here
            requestContext.HttpContext.Response.StatusCode = 404;
            requestContext.HttpContext.Response.End();
            return null;
        }

        requestContext.HttpContext.Response.Clear();
        requestContext.HttpContext.Response.Cache.SetMaxAge(TimeSpan.FromSeconds(500000));
        requestContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.Public);

        requestContext.HttpContext.Response.ContentType = GetContentType(filename);

        // find physical path to image here. 
        var path = GetPath(section);

        if (string.IsNullOrEmpty(path))
        {
            // return a 404 HttpHandler here
            requestContext.HttpContext.Response.StatusCode = 404;
            requestContext.HttpContext.Response.End();
            return null;
        }

        var filepath = requestContext.HttpContext.Server.MapPath(path + filename);
        requestContext.HttpContext.Response.WriteFile(filepath);
        requestContext.HttpContext.Response.End();
        return null;
    }

    private static string GetPath(string section)
    {
        switch (section)
        {
            case "user":
                return "~/Resources/Users/";//where you want save pics in project
        }
        return "";
    }


    private static string GetContentType(string path)
    {
        switch (Path.GetExtension(path))
        {
            case ".bmp":
                return "Image/bmp";
            case ".gif":
                return "Image/gif";
            case ".jpg":
                return "Image/jpeg";
            case ".png":
                return "Image/png";
        }
        return "";
    }
}

and change your RouteConfige like this:

public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // proccess all for protected resources with ImageRouteHandler
            routes.Add("ImagesRoute", new Route("res/{section}/{filename}", new ImageRouteHandler()));

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }

sample code for server side:

public interface IUserManagement
    {
        void UploadNewPics( IEnumerable<string> imageUrls);
    }



    public class UserManagement : IUserManagement
    {
        public void UploadNewPics(IEnumerable<string> imageUrls)
        {

            using (var ctx = new Context())
            {

                foreach (var imageUrl in imageUrls)
                {
                    //save to data base
                    .
                    .
                    .
                }

                try
                {
                    ctx.SaveChanges();
                }
                catch (Exception e)
                {
                    throw;
                }
            }
        }
    }



        public class UserApiController : ApiController
{
    [HttpPost]
    public async Task<IHttpActionResult> UploadNewPics()
    {
        if (!Request.Content.IsMimeMultipartContent())
        {
            throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
        }

        var root = HttpContext.Current.Server.MapPath("~/Resources/Users/");
        var provider = new CustomMultipartFormDataStreamProvider(root);
        try
        {
            // Read the form data.
            await Request.Content.ReadAsMultipartAsync(provider);

            IUserManagement userManagement = new UserManagement();

            var imageUrls = provider.FileData.Select(x=> Path.GetFileName(x.LocalFileName));
            //userManagement.UploadUserImage(uploadImageJson, Path.GetFileName(imageFile.LocalFileName), (long)imageFile.Headers.ContentLength);
            userManagement.UploadNewPics(imageUrls);
        }
        catch (Exception e)
        {
            return InternalServerError();
        }
        return Ok();
    }
}