Jak wysłać POST „multipart / form-data” w Androidzie za pomocą Volley

89

Czy ktoś był już w stanie wysłać multipart/form-dataPOST na Androida za pomocą Volley? Nie udało mi się przesłać za image/pngpomocą żądania POST na nasz serwer i jestem ciekawy, czy ktoś to zrobił.

Uważam, że domyślnym sposobem zrobienia tego byłoby przesłonięcie public byte[] getPostBody()w Request.javaklasie i dołączenie Filetam pustego klucza nagłówka dla granicy. Jednak konwersji pliku do mojego Stringdla Map<String, String> postParamsa następnie o to zakodowane ponownie wydaje tępy i nie bardzo elegancki. Moje próby również mi się nie powiodły. To naprawdę jedyna rzecz, która powstrzymuje nas przed przejściem do tej biblioteki.

W każdym razie wszystkie myśli i odpowiedzi są niezwykle cenione. Dziękuję za pomoc.

android http android-volley AllDayAmazing
źródło

Odpowiedzi:

75

Mogę się mylić, ale myślę, że musisz zaimplementować własne, com.android.volley.toolbox.HttpStackponieważ domyślne ( HurlStackjeśli wersja> Gingerbread lub HttpClientStack) nie radzą sobie multipart/form-data.

Edytować:

I rzeczywiście się myliłem. Udało mi się to zrobić używając MultipartEntityw Request w ten sposób:

public class MultipartRequest extends Request<String> {

    private MultipartEntity entity = new MultipartEntity();

    private static final String FILE_PART_NAME = "file";
    private static final String STRING_PART_NAME = "text";

    private final Response.Listener<String> mListener;
    private final File mFilePart;
    private final String mStringPart;

    public MultipartRequest(String url, Response.ErrorListener errorListener, Response.Listener<String> listener, File file, String stringPart)
    {
        super(Method.POST, url, errorListener);

        mListener = listener;
        mFilePart = file;
        mStringPart = stringPart;
        buildMultipartEntity();
    }

    private void buildMultipartEntity()
    {
        entity.addPart(FILE_PART_NAME, new FileBody(mFilePart));
        try
        {
            entity.addPart(STRING_PART_NAME, new StringBody(mStringPart));
        }
        catch (UnsupportedEncodingException e)
        {
            VolleyLog.e("UnsupportedEncodingException");
        }
    }

    @Override
    public String getBodyContentType()
    {
        return entity.getContentType().getValue();
    }

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

    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response)
    {
        return Response.success("Uploaded", getCacheEntry());
    }

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

Jest dość surowy, ale wypróbowałem go z obrazem i prostym ciągiem i działa. Odpowiedź jest symbolem zastępczym, w tym przypadku nie ma większego sensu zwracanie ciągu odpowiedzi. Miałem problemy z używaniem apache httpmime do korzystania z MultipartEntity, więc użyłem tego https://code.google.com/p/httpclientandroidlib/ nie wiem, czy jest lepszy sposób. Mam nadzieję, że to pomoże.

Edytować

Możesz używać httpmime bez używania httpclientandroidlib, jedyną zależnością jest httpcore.

Alex
źródło
2
@LOG_TAG: To nie obsługuje dużych plików. Nie będzie też obsługiwać paska postępu. Powodem jest to, że wszystkie dane zostaną umieszczone w jednym bajcie []. W przypadku dużych plików chcesz użyć InputStream, co nie wydaje się możliwe w przypadku volleya. Ale oni (twórcy volleya) również mówią, że volley nie jest stworzony dla dużych plików.
Patrick Boos
9
@alex czy możesz umieścić kod, jak używać MultipartRequest?
Krishna Shrestha
5
Otrzymuję ten błąd: java.lang.NoClassDefFoundError: org.apache.http.entity.ContentType
Milad
1
MultipartEntity przy użyciu apache http. Chcę to zrobić bez wieloczęściowej biblioteki Apache. jak mogę to zrobić.
JosephM
1
return entity.getContentType (). getValue (); Błąd
Wołodymyr Kulyk
14

Jak wspomniano w prezentacji na I / O (około 4:05), Volley "jest okropny" dla dużych ładunków. Jak rozumiem, oznacza to, że nie należy używać Volley do odbierania / wysyłania (dużych) plików. Patrząc na kod wydaje się, że nie jest on nawet przeznaczony do obsługi danych formularzy wieloczęściowych (np. Request.java ma getBodyContentType () z zakodowanym na stałe "application / x-www-form-urlencoded"; HttpClientStack :: createHttpRequest () może obsłużyć tylko bajt [], itp ...). Prawdopodobnie będziesz w stanie stworzyć implementację, która poradzi sobie z multipartem, ale na twoim miejscu użyję HttpClient bezpośrednio z MultipartEntity jak:

    HttpPost req = new HttpPost(composeTargetUrl());
    MultipartEntity entity = new MultipartEntity();
    entity.addPart(POST_IMAGE_VAR_NAME, new FileBody(toUpload));
    try {
        entity.addPart(POST_SESSION_VAR_NAME, new StringBody(uploadSessionId));
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
    req.setEntity(entity);

Możesz potrzebować nowszego HttpClient (tj. Nie wbudowanego) lub nawet lepiej, użyj Volley z nowszym HttpClient

Ognyan
źródło
1
Bardzo dziękuję za pomoc, Twój blog pokazuje mi coś, o czym bym nie pomyślał. Spróbuję twojej sugestii za pośrednictwem powyższego linku, jeśli nie mogę sprawić, by rozwiązanie Alexa zadziałało. Twoje zdrowie!
AllDayAmazing
Witaj @Ogre_BGR, Czy mógłbyś podać pełną próbkę, jak przesłać obraz za pomocą kodu snap. Próbowałem tylko wielu próbek, ale są one bardzo stare i nie mogę ich zmusić do działania. Dziękuję
Thiago
Obsługiwany jest teraz tryb wieloczęściowy. Spójrz na inne odpowiedzi na tej stronie.
Martin Konecny
1
@MartinKonecny, połącz poprawną odpowiedź w swoim komentarzu, aby inni użytkownicy mogli przejść bezpośrednio do niej
Ognyan
Jak mogę dodać inne parametry wraz z formatem wieloczęściowym w jednym żądaniu?
casillas
10

AKTUALIZACJA 26.08.2015:

Jeśli nie chcesz używać przestarzałego HttpEntity, oto mój działający przykładowy kod (przetestowany z ASP.Net WebAPI)

MultipartActivity.java

package com.example.volleyapp;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.v4.content.ContextCompat;
import android.view.Menu;
import android.view.MenuItem;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.example.volleyapp.BaseVolleyRequest;
import com.example.volleyapp.VolleySingleton;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class MultipartActivity extends Activity {

    final Context mContext = this;
    String mimeType;
    DataOutputStream dos = null;
    String lineEnd = "\r\n";
    String boundary = "apiclient-" + System.currentTimeMillis();
    String twoHyphens = "--";
    int bytesRead, bytesAvailable, bufferSize;
    byte[] buffer;
    int maxBufferSize = 1024 * 1024;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_multipart);             

        Drawable drawable = ContextCompat.getDrawable(mContext, R.drawable.ic_action_file_attachment_light);
        Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
        final byte[] bitmapData = byteArrayOutputStream.toByteArray();
        String url = "http://192.168.1.100/api/postfile";

        mimeType = "multipart/form-data;boundary=" + boundary;

        BaseVolleyRequest baseVolleyRequest = new BaseVolleyRequest(1, url, new Response.Listener<NetworkResponse>() {
            @Override
            public void onResponse(NetworkResponse response) {

            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

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

            @Override
            public byte[] getBody() throws AuthFailureError {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                dos = new DataOutputStream(bos);
                try {
                    dos.writeBytes(twoHyphens + boundary + lineEnd);
                    dos.writeBytes("Content-Disposition: form-data; name=\"uploaded_file\";filename=\""
                            + "ic_action_file_attachment_light.png" + "\"" + lineEnd);
                    dos.writeBytes(lineEnd);
                    ByteArrayInputStream fileInputStream = new ByteArrayInputStream(bitmapData);
                    bytesAvailable = fileInputStream.available();

                    bufferSize = Math.min(bytesAvailable, maxBufferSize);
                    buffer = new byte[bufferSize];

                    // read file and write it into form...
                    bytesRead = fileInputStream.read(buffer, 0, bufferSize);

                    while (bytesRead > 0) {
                        dos.write(buffer, 0, bufferSize);
                        bytesAvailable = fileInputStream.available();
                        bufferSize = Math.min(bytesAvailable, maxBufferSize);
                        bytesRead = fileInputStream.read(buffer, 0, bufferSize);
                    }

                    // send multipart form data necesssary after file data...
                    dos.writeBytes(lineEnd);
                    dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);

                    return bos.toByteArray();

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

        VolleySingleton.getInstance(mContext).addToRequestQueue(baseVolleyRequest);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_multipart, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

BaseVolleyRequest.java:

package com.example.volleyapp;

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;
import com.google.gson.JsonSyntaxException;


public class BaseVolleyRequest extends Request<NetworkResponse> {

    private final Response.Listener<NetworkResponse> mListener;
    private final Response.ErrorListener mErrorListener;

    public BaseVolleyRequest(String url, Response.Listener<NetworkResponse> listener, Response.ErrorListener errorListener) {
        super(0, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
    }

    public BaseVolleyRequest(int method, String url, Response.Listener<NetworkResponse> listener, Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
    }

    @Override
    protected Response<NetworkResponse> parseNetworkResponse(NetworkResponse response) {
        try {
            return Response.success(
                    response,
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (JsonSyntaxException e) {
            return Response.error(new ParseError(e));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

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

    @Override
    protected VolleyError parseNetworkError(VolleyError volleyError) {
        return super.parseNetworkError(volleyError);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }
}

KONIEC AKTUALIZACJI

Oto mój działający przykładowy kod (testowany tylko z plikami o małym rozmiarze):

public class FileUploadActivity extends Activity {

    private final Context mContext = this;
    HttpEntity httpEntity;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_file_upload);   

        Drawable drawable = getResources().getDrawable(R.drawable.ic_action_home);
        if (drawable != null) {
            Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
            ByteArrayOutputStream stream = new ByteArrayOutputStream();
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);
            final byte[] bitmapdata = stream.toByteArray();
            String url = "http://10.0.2.2/api/fileupload";
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

            // Add binary body
            if (bitmapdata != null) {
                ContentType contentType = ContentType.create("image/png");
                String fileName = "ic_action_home.png";
                builder.addBinaryBody("file", bitmapdata, contentType, fileName);
                httpEntity = builder.build();

                MyRequest myRequest = new MyRequest(Request.Method.POST, url, new Response.Listener<NetworkResponse>() {
                    @Override
                    public void onResponse(NetworkResponse response) {
                        try {                            
                            String jsonString = new String(response.data,
                                    HttpHeaderParser.parseCharset(response.headers));
                            Toast.makeText(mContext, jsonString, Toast.LENGTH_SHORT).show();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        Toast.makeText(mContext, error.toString(), Toast.LENGTH_SHORT).show();                        
                    }
                }) {
                    @Override
                    public String getBodyContentType() {
                        return httpEntity.getContentType().getValue();
                    }

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

                MySingleton.getInstance(this).addToRequestQueue(myRequest);
            }
        }
    }

    ...
}

public class MyRequest extends Request<NetworkResponse>
BNK
źródło
3
Niektóre serwery są BARDZO wybredne. Jeśli masz problemy, dodaj spację między „;” i „filename =” podczas budowania Content-Disposition i „multipart / form-data; boundary =” + boundary;
Kevin
Dzięki za komentarz @Kevin. Właściwie nie miałem wielu aplikacji serwerowych, aby to sprawdzić :-)
BNK
@HemsLodha: pls spójrz na odpowiedź RacZo na moje następujące pytanie stackoverflow.com/questions/32240177/ ... aby sprawdzić, czy to może ci pomóc, czy nie :)
BNK
1
Wysyłam żądanie wieloczęściowe post z volleyem i ostatecznie ustawiam parametr na adres URL i działa. Dzięki za pomoc @BNK.
JosephM
@ user3561494 nie jest zalecane dla dużych plików, takich jak wideo
BNK,
9

Wypełnij żądanie wieloczęściowe z postępem przesyłania

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.util.CharsetUtils;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyLog;
import com.beusoft.app.AppContext;

public class MultipartRequest extends Request<String> {

    MultipartEntityBuilder entity = MultipartEntityBuilder.create();
    HttpEntity httpentity;
    private String FILE_PART_NAME = "files";

    private final Response.Listener<String> mListener;
    private final File mFilePart;
    private final Map<String, String> mStringPart;
    private Map<String, String> headerParams;
    private final MultipartProgressListener multipartProgressListener;
    private long fileLength = 0L;

    public MultipartRequest(String url, Response.ErrorListener errorListener,
            Response.Listener<String> listener, File file, long fileLength,
            Map<String, String> mStringPart,
            final Map<String, String> headerParams, String partName,
            MultipartProgressListener progLitener) {
        super(Method.POST, url, errorListener);

        this.mListener = listener;
        this.mFilePart = file;
        this.fileLength = fileLength;
        this.mStringPart = mStringPart;
        this.headerParams = headerParams;
        this.FILE_PART_NAME = partName;
        this.multipartProgressListener = progLitener;

        entity.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
        try {
            entity.setCharset(CharsetUtils.get("UTF-8"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        buildMultipartEntity();
        httpentity = entity.build();
    }

    // public void addStringBody(String param, String value) {
    // if (mStringPart != null) {
    // mStringPart.put(param, value);
    // }
    // }

    private void buildMultipartEntity() {
        entity.addPart(FILE_PART_NAME, new FileBody(mFilePart, ContentType.create("image/gif"), mFilePart.getName()));
        if (mStringPart != null) {
            for (Map.Entry<String, String> entry : mStringPart.entrySet()) {
                entity.addTextBody(entry.getKey(), entry.getValue());
            }
        }
    }

    @Override
    public String getBodyContentType() {
        return httpentity.getContentType().getValue();
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            httpentity.writeTo(new CountingOutputStream(bos, fileLength,
                    multipartProgressListener));
        } catch (IOException e) {
            VolleyLog.e("IOException writing to ByteArrayOutputStream");
        }
        return bos.toByteArray();
    }

    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {

        try {
//          System.out.println("Network Response "+ new String(response.data, "UTF-8"));
            return Response.success(new String(response.data, "UTF-8"),
                    getCacheEntry());
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            // fuck it, it should never happen though
            return Response.success(new String(response.data), getCacheEntry());
        }
    }

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

//Override getHeaders() if you want to put anything in header

    public static interface MultipartProgressListener {
        void transferred(long transfered, int progress);
    }

    public static class CountingOutputStream extends FilterOutputStream {
        private final MultipartProgressListener progListener;
        private long transferred;
        private long fileLength;

        public CountingOutputStream(final OutputStream out, long fileLength,
                final MultipartProgressListener listener) {
            super(out);
            this.fileLength = fileLength;
            this.progListener = listener;
            this.transferred = 0;
        }

        public void write(byte[] b, int off, int len) throws IOException {
            out.write(b, off, len);
            if (progListener != null) {
                this.transferred += len;
                int prog = (int) (transferred * 100 / fileLength);
                this.progListener.transferred(this.transferred, prog);
            }
        }

        public void write(int b) throws IOException {
            out.write(b);
            if (progListener != null) {
                this.transferred++;
                int prog = (int) (transferred * 100 / fileLength);
                this.progListener.transferred(this.transferred, prog);
            }
        }

    }
}

Przykładowe użycie

protected <T> void uploadFile(final String tag, final String url,
            final File file, final String partName,         
            final Map<String, String> headerParams,
            final Response.Listener<String> resultDelivery,
            final Response.ErrorListener errorListener,
            MultipartProgressListener progListener) {
        AZNetworkRetryPolicy retryPolicy = new AZNetworkRetryPolicy();

        MultipartRequest mr = new MultipartRequest(url, errorListener,
                resultDelivery, file, file.length(), null, headerParams,
                partName, progListener);

        mr.setRetryPolicy(retryPolicy);
        mr.setTag(tag);

        Volley.newRequestQueue(this).add(mr);

    }
AZ_
źródło
Cześć @AZ_ - próbowałem twojego kodu: Ale pojawia się ten błąd: MultipartRequest.getBody: IOException zapisujący do ByteArrayOutputStream. Czy możesz pomóc, proszę
Thiago
Nie mam twojego kodu, nie mogę zasugerować nic lepszego, aby otworzyć kolejne pytanie, najprawdopodobniej zabrakło pamięci wirtualnej.
AZ_,
1
Mam otwarte I nowe pytanie: stackoverflow.com/questions/31474585/… Czy możesz pomóc, proszę. dziękuję
Thiago
Jak mogę dodać inne parametry wraz z formatem wieloczęściowym w jednym żądaniu?
casillas
@casillas dodaje parę klucz-wartość do nagłówka żądania.
AZ_
8

Bardzo proste podejście dla programistów, którzy chcą po prostu wysłać parametry POST w żądaniu wieloczęściowym.

Wprowadź następujące zmiany w klasie rozszerzającej Request.java

Najpierw zdefiniuj te stałe:

String BOUNDARY = "s2retfgsGSRFsERFGHfgdfgw734yhFHW567TYHSrf4yarg"; //This the boundary which is used by the server to split the post parameters.
String MULTIPART_FORMDATA = "multipart/form-data;boundary=" + BOUNDARY;

Dodaj funkcję pomocniczą, aby utworzyć treść posta:

private String createPostBody(Map<String, String> params) {
        StringBuilder sbPost = new StringBuilder();
        if (params != null) {
            for (String key : params.keySet()) {
                if (params.get(key) != null) {
                    sbPost.append("\r\n" + "--" + BOUNDARY + "\r\n");
                    sbPost.append("Content-Disposition: form-data; name=\"" + key + "\"" + "\r\n\r\n");
                    sbPost.append(params.get(key).toString());
                }
            }
        }
        return sbPost.toString();
    }

Zastąp getBody () i getBodyContentType

public String getBodyContentType() {
    return MULTIPART_FORMDATA;
}

public byte[] getBody() throws AuthFailureError {
        return createPostBody(getParams()).getBytes();
}
Arpit Ratan
źródło
1
Bardzo prosto i działa doskonale! Musiałem to zrobić sbPost.append("--" + BOUNDARY + "--");tuż przed powrotem, ponieważ API, którego używam, wymaga tagu zamykającego
Sirens
1
Dziękuję bardzo :)
Arpit Ratan
Dzięki! To działało dla mnie na front-endzie, ale back-end, szczególnie nodejs, ma problem z jego przeanalizowaniem? Czy doświadczyłeś czegoś takiego?
Woppi,
1
Przepraszam, że nie mam doświadczenia z
backendem
@Arpit dzięki, udało mi się rozwiązać mój problem, używając tej klasy pomocniczej zamiast gist.github.com/anggadarkprince/ ...
Woppi
4

Pierwsza odpowiedź na SO.

Napotkałem ten sam problem i okazało się, że kod @alex jest bardzo pomocny. Dokonałem kilku prostych modyfikacji, aby przekazać tyle parametrów, ile potrzeba, przez HashMap i w zasadzie skopiowałem parseNetworkResponse()z StringRequest. Szukałem w Internecie i byłem bardzo zaskoczony, gdy dowiedziałem się, że tak rzadko odpowiada się na tak powszechne zadanie. W każdym razie chciałbym, żeby kod pomógł:

public class MultipartRequest extends Request<String> {

private MultipartEntity entity = new MultipartEntity();

private static final String FILE_PART_NAME = "image";

private final Response.Listener<String> mListener;
private final File file;
private final HashMap<String, String> params;

public MultipartRequest(String url, Response.Listener<String> listener, Response.ErrorListener errorListener, File file, HashMap<String, String> params)
{
    super(Method.POST, url, errorListener);

    mListener = listener;
    this.file = file;
    this.params = params;
    buildMultipartEntity();
}

private void buildMultipartEntity()
{
    entity.addPart(FILE_PART_NAME, new FileBody(file));
    try
    {
        for ( String key : params.keySet() ) {
            entity.addPart(key, new StringBody(params.get(key)));
        }
    }
    catch (UnsupportedEncodingException e)
    {
        VolleyLog.e("UnsupportedEncodingException");
    }
}

@Override
public String getBodyContentType()
{
    return entity.getContentType().getValue();
}

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

/**
 * copied from Android StringRequest class
 */
@Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
    String parsed;
    try {
        parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
    } catch (UnsupportedEncodingException e) {
        parsed = new String(response.data);
    }
    return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}

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

Możesz użyć tej klasy w następujący sposób:

    HashMap<String, String> params = new HashMap<String, String>();

    params.put("type", "Some Param");
    params.put("location", "Some Param");
    params.put("contact",  "Some Param");


    MultipartRequest mr = new MultipartRequest(url, new Response.Listener<String>(){

        @Override
        public void onResponse(String response) {
            Log.d("response", response);
        }

    }, new Response.ErrorListener(){

        @Override
        public void onErrorResponse(VolleyError error) {
            Log.e("Volley Request Error", error.getLocalizedMessage());
        }

    }, f, params);

    Volley.newRequestQueue(this).add(mr);
Michael Shang
źródło
0

Kolejne rozwiązanie, bardzo lekkie o dużej wydajności z dużym ładunkiem:

Biblioteka klienta asynchronicznego klienta HTTP dla systemu Android: http://loopj.com/android-async-http/

private static AsyncHttpClient client = new AsyncHttpClient();

private void uploadFileExecute(File file) {

    RequestParams params = new RequestParams();

    try { params.put("photo", file); } catch (FileNotFoundException e) {}

    client.post(getUrl(), params,

        new AsyncHttpResponseHandler() {

            public void onSuccess(String result) {

                Log.d(TAG,"uploadFile response: "+result);

            };

            public void onFailure(Throwable arg0, String errorMsg) {

                Log.d(TAG,"uploadFile ERROR!");

            };

        }

    );

}
Hpsaturn
źródło
2
duże rozmiary plików powodują wyjątek braku pamięci
Ravi
1
@Ravi +1 ta biblioteka jest do bani za przesyłanie dużych plików
Anton
jeśli chcesz wysyłać duże pliki, użyj bibliotek Apache Mime dla wielu części, a następnie opublikuj je za pomocą tej biblioteki.
Ravi
Musisz skompresować rozmiar obrazu, a następnie użyć tej biblioteki, aby załadować obraz. Znalazłem rozwiązanie z poniższego adresu URL: programmerguru.com/android-tutorial/ ... Mam nadzieję, że zaoszczędzi to komuś czasu.
Milan Sheth
@Ravi apache mime da ci konflikt i zduplikowany błąd klasy.
Muhammad Saqib
0

Oto proste rozwiązanie i kompletny przykład przesyłania pliku za pomocą Volley Android

1) Import Gradle 

compile 'dev.dworks.libs:volleyplus:+'

2) Teraz utwórz klasę RequestManager

public class RequestManager {
    private static RequestManager mRequestManager;
    /**
     * Queue which Manages the Network Requests :-)
     */
    private static RequestQueue mRequestQueue;
    // ImageLoader Instance

    private RequestManager() {

    }

    public static RequestManager get(Context context) {

        if (mRequestManager == null)
            mRequestManager = new RequestManager();

        return mRequestManager;
    }

    /**
     * @param context application context
     */
    public static RequestQueue getnstance(Context context) {

        if (mRequestQueue == null) {
            mRequestQueue = Volley.newRequestQueue(context);
        }

        return mRequestQueue;

    }


}

3) Teraz utwórz klasę do obsługi żądania przesłania File WebService

public class WebService {
    private RequestQueue mRequestQueue;
    private static WebService apiRequests = null;

    public static WebService getInstance() {
        if (apiRequests == null) {
            apiRequests = new WebService();
            return apiRequests;
        }
        return apiRequests;
    }
    public void updateProfile(Context context, String doc_name, String doc_type, String appliance_id, File file, Response.Listener<String> listener, Response.ErrorListener errorListener) {
        SimpleMultiPartRequest request = new SimpleMultiPartRequest(Request.Method.POST, "YOUR URL HERE", listener, errorListener);
//        request.setParams(data);
        mRequestQueue = RequestManager.getnstance(context);
        request.addMultipartParam("token", "text", "tdfysghfhsdfh");
        request.addMultipartParam("parameter_1", "text", doc_name);
        request.addMultipartParam("dparameter_2", "text", doc_type);
        request.addMultipartParam("parameter_3", "text", appliance_id);
            request.addFile("document_file", file.getPath());

        request.setFixedStreamingMode(true);
        mRequestQueue.add(request);
    }
}

4) A teraz wywołaj taką metodę, aby trafić do usługi 

public class Main2Activity extends AppCompatActivity implements Response.ErrorListener, Response.Listener<String>{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        Button button=(Button)findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                uploadData();
            }
        });
    }

    private void uploadData() {
        WebService.getInstance().updateProfile(getActivity(), "appl_doc", "appliance", "1", mChoosenFile, this, this);
    }

    @Override
    public void onErrorResponse(VolleyError error) {

    }

    @Override
    public void onResponse(String response) {
     //Your response here 
    }
}
Szybki uczeń
źródło
Otrzymuję ten błąd z Twoim rozwiązaniem: java.lang.NoSuchMethodError: Brak metody bezpośredniej <init> (ILjava / lang / String; Lcom / android / volley / Request $ Priority; Lcom / android / volley / Response $ ErrorListener; Lcom / android / volley / RetryPolicy;) V w klasie Lcom / android / volley / Request; lub jego superklasy (deklaracja „com.android.volley.Request” pojawia się w /data/data/com.footballscout.app/files/instant-run/dex/slice-slice_4-classes.dex)
SpyZip
czy sprawdziłeś poprawność gradle i import w klasach?
Szybki uczeń
Użyłem raz opisanego tutaj i Twojej odpowiedzi github.com/DWorkS/VolleyPlus
SpyZip
1
i sprawdź swoje importy w klasie, w której kiedykolwiek używasz, ponieważ nie możesz używać poprawnych importów dla volleya, tak jak błąd wskazuje na odbiornik błędów, sprawdź ponownie import i gradle, a następnie wyczyść projekt, dziękuję, jeśli nadal znajdziesz problem, daj mi znać
Szybki uczeń
-1

To jest mój sposób na zrobienie tego. Może być przydatny dla innych:

private void updateType(){
    // Log.i(TAG,"updateType");
     StringRequest request = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {

         @Override
         public void onResponse(String response) {
             // running on main thread-------
             try {
                 JSONObject res = new JSONObject(response);
                 res.getString("result");
                 System.out.println("Response:" + res.getString("result"));

                 }else{
                     CustomTast ct=new CustomTast(context);
                     ct.showCustomAlert("Network/Server Disconnected",R.drawable.disconnect);
                 }

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

                 //Log.e("Response", "==> " + e.getMessage());
             }
         }
     }, new Response.ErrorListener() {
         @Override
         public void onErrorResponse(VolleyError volleyError) {
             // running on main thread-------
             VolleyLog.d(TAG, "Error: " + volleyError.getMessage());

         }
     }) {
         protected Map<String, String> getParams() {
             HashMap<String, String> hashMapParams = new HashMap<String, String>();
             hashMapParams.put("key", "value");
             hashMapParams.put("key", "value");
             hashMapParams.put("key", "value"));
             hashMapParams.put("key", "value");
             System.out.println("Hashmap:" + hashMapParams);
             return hashMapParams;
         }
     };
     AppController.getInstance().addToRequestQueue(request);

 }
koteswara DK
źródło