Post multipart demande avec Android SDK

Question

Je suis en train de faire quelque chose que je pensais serait relativement simple: Télécharger une image sur un serveur avec le SDK Android. Je me suis trouvé beaucoup d'exemple de code:

http://groups.google.com/group/android-developers/browse_thread/thread/f9e17bbaf50c5fc/46145fcacd450e48

http://linklens.blogspot.com/2009/06/android-multipart-upload.html

Mais ne travaillant pas pour moi. La confusion je continuer à courir, c'est ce qui est vraiment nécessaire de faire une demande multiparties. Quel est le plus simple moyen d'avoir un multipart télécharger (avec une image) pour Android?

De l'aide ou des conseils seraient grandement appréciés!

Answer 1

Mise à jour le 29 avril 2014:

Ma réponse est une sorte de vieux maintenant, et je suppose que vous avez plutôt envie d'utiliser une sorte de haut niveau de la bibliothèque tels que la Rénovation.

---

Basé sur ce blog, je suis venu avec la solution suivante: http://blog.tacticalnuclearstrike.com/2010/01/using-multipartentity-in-android-applications/

Vous devrez télécharger d'autres bibliothèques pour obtenir de l' MultipartEntity de course!

1) Télécharger httpcomponents-client-4.1.zip à partir de http://james.apache.org/download.cgi#Apache_Mime4J et d'ajouter apache-mime4j-0.6.1.jar pour votre projet.

2) Télécharger httpcomponents-client-4.1-bin.zip à partir de http://hc.apache.org/downloads.cgi et d'ajouter httpclient-4.1.jar, httpcore-4.1.jar et httpmime-4.1.jar pour votre projet.

3) Utiliser l'exemple de code ci-dessous.

private DefaultHttpClient mHttpClient;


public ServerCommunication() {
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
    mHttpClient = new DefaultHttpClient(params);
}


public void uploadUserPhoto(File image) {

    try {

        HttpPost httppost = new HttpPost("some url");

        MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);  
        multipartEntity.addPart("Title", new StringBody("Title"));
        multipartEntity.addPart("Nick", new StringBody("Nick"));
        multipartEntity.addPart("Email", new StringBody("Email"));
        multipartEntity.addPart("Description", new StringBody(Settings.SHARE.TEXT));
        multipartEntity.addPart("Image", new FileBody(image));
        httppost.setEntity(multipartEntity);

        mHttpClient.execute(httppost, new PhotoUploadResponseHandler());

    } catch (Exception e) {
        Log.e(ServerCommunication.class.getName(), e.getLocalizedMessage(), e);
    }
}

private class PhotoUploadResponseHandler implements ResponseHandler<Object> {

    @Override
    public Object handleResponse(HttpResponse response)
            throws ClientProtocolException, IOException {

        HttpEntity r_entity = response.getEntity();
        String responseString = EntityUtils.toString(r_entity);
        Log.d("UPLOAD", responseString);

        return null;
    }

}

Answer 2

En tant que MultiPartEntity est obsolète. Voici donc la nouvelle façon de faire! Et vous avez seulement besoin d' httpcore.jar(latest) et httpmime.jar(latest) télécharger à partir de Apache site.

        try
        {
            HttpClient client = new DefaultHttpClient();

            HttpPost post = new HttpPost(URL);

            MultipartEntityBuilder entityBuilder = MultipartEntityBuilder.create();
            entityBuilder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);

            entityBuilder.addTextBody(USER_ID, userId);
            entityBuilder.addTextBody(NAME, name);
            entityBuilder.addTextBody(TYPE, type);
            entityBuilder.addTextBody(COMMENT, comment);
            entityBuilder.addTextBody(LATITUDE, String.valueOf(User.Latitude));
            entityBuilder.addTextBody(LONGITUDE, String.valueOf(User.Longitude));

            if(file != null)
            {
                entityBuilder.addBinaryBody(IMAGE, file);
            }

            HttpEntity entity = entityBuilder.build();

            post.setEntity(entity);

            HttpResponse response = client.execute(post);

            HttpEntity httpEntity = response.getEntity();

            result = EntityUtils.toString(httpEntity);

            Log.v("result", result);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

Answer 3

Plus facile, léger (32k), et beaucoup plus de performance:

Android Http Asynchrone de la bibliothèque du Client: http://loopj.com/android-async-http/

Mise en œuvre:

Comment envoyer un "multipart/form-data" POST dans Android avec terrain de Volley -

Answer 4

Essayez ceci:

    public void SendMultipartFile() {
    Log.d(TAG, "UPLOAD: SendMultipartFile");
    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpPost httppost = new HttpPost( <url> );

    File file = new File("/sdcard/spider.jpg");

    Log.d(TAG, "UPLOAD: setting up multipart entity");

    MultipartEntity mpEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
    Log.d(TAG, "UPLOAD: file length = " + file.length());
    Log.d(TAG, "UPLOAD: file exist = " + file.exists());

    try {
        mpEntity.addPart("datafile", new FileBody(file, "application/octet"));
        mpEntity.addPart("id", new StringBody("1"));
    } catch (UnsupportedEncodingException e1) {
        Log.d(TAG, "UPLOAD: UnsupportedEncodingException");
        e1.printStackTrace();
    }

    httppost.setEntity(mpEntity);
    Log.d(TAG, "UPLOAD: executing request: " + httppost.getRequestLine());
    Log.d(TAG, "UPLOAD: request: " + httppost.getEntity().getContentType().toString());


    HttpResponse response;
    try {
        Log.d(TAG, "UPLOAD: about to execute");
        response = httpclient.execute(httppost);
        Log.d(TAG, "UPLOAD: executed");
        HttpEntity resEntity = response.getEntity();
        Log.d(TAG, "UPLOAD: respose code: " + response.getStatusLine().toString());
        if (resEntity != null) {
            Log.d(TAG, "UPLOAD: " + EntityUtils.toString(resEntity));
        }
        if (resEntity != null) {
            resEntity.consumeContent();
        }
    } catch (ClientProtocolException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Answer 5

Je recommande fortement Loopj.

J'ai utilisé avec succès pour télécharger plusieurs fichiers à la fois, y compris les différents types mime. Simplement faire ceci:

File myVideo = new File("/path/to/myvideo.mp4");
File myPic = new File("/path/to/mypic.jpg");
RequestParams params = new RequestParams();
try {
  params.put("profile_picture", myPic);
  params.put("my_video", myVideo);
} catch(FileNotFoundException e) {}

Pour les grands ou le nombre de fichiers que vous pourriez avoir à augmenter le délai d'expiration montant reste le délai d'expiration par défaut est utilisée, ce qui est peut-être trop court:

client.setTimeout(500000) //make this the appropriate timeout in milliseconds

Consultez ce lien pour une description complète de loopj et comment l'utiliser, et de loin, la méthode la plus simple async http bibliothèque que j'ai trouver:

http://loopj.com/android-async-http/ http://loopj.com/android-async-http/doc/com/loopj/android/http/AsyncHttpClient.html