Publier une demande multipart avec Android SDK
https://stackoverflow.com/questions/2017414
-
19-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je suis en train de faire quelque chose que je pensais être relativement simple: Ajouter une image à un serveur avec le SDK Android. Je trouve beaucoup d'exemples de code:
http://linklens.blogspot.com/2009/06/ android-multipart-Upload.html
Mais ni le travail pour moi. La confusion que je continue à courir en est ce qui est vraiment nécessaire pour faire une demande multipart. Quel est le simple moyen d'avoir un téléchargement multipart (avec une image) pour Android?
Toute aide ou des conseils seraient grandement appréciés!
La solution
Mise à jour Avril 29 2014:
Ma réponse est un peu vieux maintenant et je suppose que vous voulez plutôt d'utiliser une sorte de bibliothèque de haut niveau tels que Rénovation .
Sur la base de 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 des bibliothèques supplémentaires pour obtenir MultipartEntity courir!
1) Télécharger httpcomponents-client-4.1.zip de http://james.apache.org/download.cgi# Apache_Mime4J et ajouter apache-mime4j-0.6.1.jar à votre projet.
2) Télécharger httpcomponents-client-4.1-bin.zip de http://hc.apache.org/downloads.cgi et ajouter httpclient-4.1.jar, httpcore-4.1.jar et httpmime-4.1.jar à votre projet.
3) Ce code d'exemple 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;
}
}
Autres conseils
MultiPartEntity est dépréciée . Voici donc la nouvelle façon de le faire! Et vous avez seulement besoin httpcore.jar(latest) et httpmime.jar(latest) les télécharger à partir du site Apache.
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();
}
Voici la solution LÉGER PONDERE qui a fonctionné pour moi sans HTTPCore externe et ces libs. Je faisais face question de 64K méthodes ont donc aucune option gauche pour éviter les bibliothèques HTTPCore
import java.util.List;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.List;
/**
* This utility class provides an abstraction layer for sending multipart HTTP
* POST requests to a web server.
*
* @author www.codejava.net
*/
public class MultipartUtility {
private final String boundary;
private static final String LINE_FEED = "\r\n";
private HttpURLConnection httpConn;
private String charset;
private OutputStream outputStream;
private PrintWriter writer;
/**
* This constructor initializes a new HTTP POST request with content type
* is set to multipart/form-data
*
* @param requestURL
* @param charset
* @throws IOException
*/
public MultipartUtility(String requestURL, String charset)
throws IOException {
this.charset = charset;
// creates a unique boundary based on time stamp
boundary = "===" + System.currentTimeMillis() + "===";
URL url = new URL(requestURL);
httpConn = (HttpURLConnection) url.openConnection();
httpConn.setUseCaches(false);
httpConn.setDoOutput(true); // indicates POST method
httpConn.setDoInput(true);
httpConn.setRequestProperty("Content-Type",
"multipart/form-data; boundary=" + boundary);
httpConn.setRequestProperty("User-Agent", "CodeJava Agent");
httpConn.setRequestProperty("Test", "Bonjour");
outputStream = httpConn.getOutputStream();
writer = new PrintWriter(new OutputStreamWriter(outputStream, charset),
true);
}
/**
* Adds a form field to the request
*
* @param name field name
* @param value field value
*/
public void addFormField(String name, String value) {
writer.append("--" + boundary).append(LINE_FEED);
writer.append("Content-Disposition: form-data; name=\"" + name + "\"")
.append(LINE_FEED);
writer.append("Content-Type: text/plain; charset=" + charset).append(
LINE_FEED);
writer.append(LINE_FEED);
writer.append(value).append(LINE_FEED);
writer.flush();
}
/**
* Adds a upload file section to the request
*
* @param fieldName name attribute in <input type="file" name="..." />
* @param uploadFile a File to be uploaded
* @throws IOException
*/
public void addFilePart(String fieldName, File uploadFile)
throws IOException {
String fileName = uploadFile.getName();
writer.append("--" + boundary).append(LINE_FEED);
writer.append(
"Content-Disposition: form-data; name=\"" + fieldName
+ "\"; filename=\"" + fileName + "\"")
.append(LINE_FEED);
writer.append(
"Content-Type: "
+ URLConnection.guessContentTypeFromName(fileName))
.append(LINE_FEED);
writer.append("Content-Transfer-Encoding: binary").append(LINE_FEED);
writer.append(LINE_FEED);
writer.flush();
FileInputStream inputStream = new FileInputStream(uploadFile);
byte[] buffer = new byte[4096];
int bytesRead = -1;
while ((bytesRead = inputStream.read(buffer)) != -1) {
outputStream.write(buffer, 0, bytesRead);
}
outputStream.flush();
inputStream.close();
writer.append(LINE_FEED);
writer.flush();
}
/**
* Adds a header field to the request.
*
* @param name - name of the header field
* @param value - value of the header field
*/
public void addHeaderField(String name, String value) {
writer.append(name + ": " + value).append(LINE_FEED);
writer.flush();
}
/**
* Completes the request and receives response from the server.
*
* @return a list of Strings as response in case the server returned
* status OK, otherwise an exception is thrown.
* @throws IOException
*/
public List<String> finish() throws IOException {
List<String> response = new ArrayList<String>();
writer.append(LINE_FEED).flush();
writer.append("--" + boundary + "--").append(LINE_FEED);
writer.close();
// checks server's status code first
int status = httpConn.getResponseCode();
if (status == HttpURLConnection.HTTP_OK) {
BufferedReader reader = new BufferedReader(new InputStreamReader(
httpConn.getInputStream()));
String line = null;
while ((line = reader.readLine()) != null) {
response.add(line);
}
reader.close();
httpConn.disconnect();
} else {
throw new IOException("Server returned non-OK status: " + status);
}
return response;
}
}
USAGES
private void uploadMedia() {
try {
String charset = "UTF-8";
File uploadFile1 = new File("/sdcard/myvideo.mp4");
String requestURL = Data.BASE_URL+Data.URL_UPLOAD_REACTION_TEST;
MultipartUtility multipart = new MultipartUtility(requestURL, charset);
// multipart.addHeaderField("User-Agent", "CodeJava");
// multipart.addHeaderField("Test-Header", "Header-Value");
multipart.addFormField("friend_id", "Cool Pictures");
multipart.addFormField("userid", "Java,upload,Spring");
multipart.addFilePart("uploadedfile", uploadFile1);
List<String> response = multipart.finish();
Log.v("rht", "SERVER REPLIED:");
for (String line : response) {
Log.v("rht", "Line : "+line);
}
} catch (Exception e) {
e.printStackTrace();
}
}
Code PHP pour accepter le téléchargement
<?php
$friend_id = $_REQUEST['friend_id'];
$userid = $_REQUEST['userid'];
echo 'friend_id : '.$friend_id. ' userid '.$userid;
move_uploaded_file($_FILES['uploadedfile']['tmp_name'], "./uploads/".$_FILES["uploadedfile"]["name"]);
?>
Plus facile, léger (32k), et bien d'autres performances:
Android Asynchronous Http bibliothèque Client: http://loopj.com/android-async-http/
Mise en œuvre:
Comment d'envoyer un POST « multipart / form-data » dans Android avec Volley
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();
}
}
Je recommande fortement Loopj.
Je l'ai utilisé avec succès pour télécharger plusieurs fichiers à la fois, y compris les différents types de mime. Il suffit de 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 fichiers volumineux ou de nombreux que vous pourriez avoir à augmenter la quantité de délai d'attente sinon le délai d'attente par défaut est utilisé qui pourrait être trop court:
client.setTimeout(500000) //make this the appropriate timeout in milliseconds
S'il vous plaît voir ce lien pour obtenir une description complète de loopj et comment l'utiliser, de loin la meilleure bibliothèque http async Je suis venu dans:
http://loopj.com/android-async-http/ http://loopj.com/android-async -http / doc / com / loopj / android / http / AsyncHttpClient.html
Supprimer tous vos httpclient, httpmime dépendance et ajouter cette compile 'commons-httpclient:commons-httpclient:3.1' de dépendance. Cette dépendance a construit en MultipartRequestEntity de sorte que vous pouvez facilement télécharger un ou plusieurs fichiers sur le serveur
public class FileUploadUrlConnection extends AsyncTask<String, String, String> {
private Context context;
private String url;
private List<File> files;
public FileUploadUrlConnection(Context context, String url, List<File> files) {
this.context = context;
this.url = url;
this.files = files;
}
@Override
protected String doInBackground(String... params) {
HttpClient client = new HttpClient();
PostMethod post = new PostMethod(url);
HttpClientParams connectionParams = new HttpClientParams();
post.setRequestHeader(// Your header goes here );
try {
Part[] parts = new Part[files.size()];
for (int i=0; i<files.size(); i++) {
Part part = new FilePart(files.get(i).getName(), files.get(i));
parts[i] = part;
}
MultipartRequestEntity entity = new MultipartRequestEntity(parts, connectionParams);
post.setRequestEntity(entity);
int statusCode = client.executeMethod(post);
String response = post.getResponseBodyAsString();
Log.v("Multipart "," "+response);
if(statusCode == 200) {
return response;
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
Vous pouvez également ajouter la demande et le délai de réponse
client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 10000);
client.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, 10000);
public class Multipart{
private final Map<String, String> headrs;
private String url;
private HttpURLConnection con;
private OutputStream os;
private String delimiter = "--";
private String boundary = "TRR" + Long.toString(System.currentTimeMillis()) + "TRR";
public Multipart (String url, Map<String, String> headers) {
this.url = url;
this.headrs = headers;
}
public void connectForMultipart() throws Exception {
con = (HttpURLConnection) (new URL(url)).openConnection();
con.setRequestMethod("POST");
con.setDoInput(true);
con.setDoOutput(true);
con.setRequestProperty("Connection", "Keep-Alive");
for (Map.Entry<String, String> entry : headrs.entrySet()) {
con.setRequestProperty(entry.getKey(), entry.getValue());
}
con.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
con.connect();
os = con.getOutputStream();
}
public void addFormPart(String paramName, String value) throws Exception {
writeParamData(paramName, value);
}
public void addFilePart(String paramName, String fileName, byte[] data) throws Exception {
os.write((delimiter + boundary + "\r\n").getBytes());
os.write(("Content-Disposition: form-data; name=\"" + paramName + "\"; filename=\"" + fileName + "\"\r\n").getBytes());
os.write(("Content-Type: application/octet-stream\r\n").getBytes());
os.write(("Content-Transfer-Encoding: binary\r\n").getBytes());
os.write("\r\n".getBytes());
os.write(data);
os.write("\r\n".getBytes());
}
public void finishMultipart() throws Exception {
os.write((delimiter + boundary + delimiter + "\r\n").getBytes());
}
public String getResponse() throws Exception {
InputStream is = con.getInputStream();
byte[] b1 = new byte[1024];
StringBuffer buffer = new StringBuffer();
while (is.read(b1) != -1)
buffer.append(new String(b1));
con.disconnect();
return buffer.toString();
}
private void writeParamData(String paramName, String value) throws Exception {
os.write((delimiter + boundary + "\r\n").getBytes());
os.write("Content-Type: text/plain\r\n".getBytes());//;charset=utf-8
os.write(("Content-Disposition: form-data; name=\"" + paramName + "\"\r\n").getBytes());
;
os.write(("\r\n" + value + "\r\n").getBytes());
}
}
Ensuite, appelez ci-dessous
Multipart multipart = new Multipart(url__, map);
multipart .connectForMultipart();
multipart .addFormPart(entry.getKey(), entry.getValue());
multipart .addFilePart(KeyName, "FileName", imagedata);
multipart .finishMultipart();
Je recommanderai Ion bibliothèque, il utilise 3 et vous pouvez dépendances trouver tous les trois fichiers jar à ces deux sites:
https://github.com/koush/ion#jars (ion et androidasync)
try {
Ion.with(this, "http://www.urlthatyouwant.com/post/page")
.setMultipartParameter("field1", "This is field number 1")
.setMultipartParameter("field2", "Field 2 is shorter")
.setMultipartFile("imagefile",
new File(Environment.getExternalStorageDirectory()+"/testfile.jpg"))
.asString()
.setCallback(new FutureCallback<String>() {
@Override
public void onCompleted(Exception e, String result) {
System.out.println(result);
}});
} catch(Exception e) {
// Do something about exceptions
System.out.println("exception: " + e);
}
se déroulera async et le rappel sera exécuté dans le thread d'interface utilisateur une fois une réponse est reçue Je suis fermement recomned que vous allez à la https://github.com/koush/ion pour plus d'informations futher
Voici une approche simple si vous utilisez la bibliothèque Volley PSBA.
Étendre la Request<T> classe comme suit: -
public class MultipartRequest extends Request<String> {
private static final String FILE_PART_NAME = "file";
private final Response.Listener<String> mListener;
private final Map<String, File> mFilePart;
private final Map<String, String> mStringPart;
MultipartEntityBuilder entity = MultipartEntityBuilder.create();
HttpEntity httpentity;
public MultipartRequest(String url, Response.ErrorListener errorListener,
Response.Listener<String> listener, Map<String, File> file,
Map<String, String> mStringPart) {
super(Method.POST, url, errorListener);
mListener = listener;
mFilePart = file;
this.mStringPart = mStringPart;
entity.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
buildMultipartEntity();
}
public void addStringBody(String param, String value) {
mStringPart.put(param, value);
}
private void buildMultipartEntity() {
for (Map.Entry<String, File> entry : mFilePart.entrySet()) {
// entity.addPart(entry.getKey(), new FileBody(entry.getValue(), ContentType.create("image/jpeg"), entry.getKey()));
try {
entity.addBinaryBody(entry.getKey(), Utils.toByteArray(new FileInputStream(entry.getValue())), ContentType.create("image/jpeg"), entry.getKey() + ".JPG");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
for (Map.Entry<String, String> entry : mStringPart.entrySet()) {
if (entry.getKey() != null && entry.getValue() != null) {
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 = entity.build();
httpentity.writeTo(bos);
} catch (IOException e) {
VolleyLog.e("IOException writing to ByteArrayOutputStream");
}
return bos.toByteArray();
}
@Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
Log.d("Response", new String(response.data));
return Response.success(new String(response.data), getCacheEntry());
}
@Override
protected void deliverResponse(String response) {
mListener.onResponse(response);
}
}
Vous pouvez créer et ajouter une demande comme -
Map<String, String> params = new HashMap<>();
params.put("name", name.getText().toString());
params.put("email", email.getText().toString());
params.put("user_id", appPreferences.getInt( Utils.PROPERTY_USER_ID, -1) + "");
params.put("password", password.getText().toString());
params.put("imageName", pictureName);
Map<String, File> files = new HashMap<>();
files.put("photo", new File(Utils.LOCAL_RESOURCE_PATH + pictureName));
MultipartRequest multipartRequest = new MultipartRequest(Utils.BASE_URL + "editprofile/" + appPreferences.getInt(Utils.PROPERTY_USER_ID, -1), new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// TODO Auto-generated method stub
Log.d("Error: ", error.toString());
FugaDialog.showErrorDialog(ProfileActivity.this);
}
}, new Response.Listener<String>() {
@Override
public void onResponse(String jsonResponse) {
JSONObject response = null;
try {
Log.d("jsonResponse: ", jsonResponse);
response = new JSONObject(jsonResponse);
} catch (JSONException e) {
e.printStackTrace();
}
try {
if (response != null && response.has("statusmessage") && response.getBoolean("statusmessage")) {
updateLocalRecord();
}
} catch (JSONException e) {
e.printStackTrace();
}
FugaDialog.dismiss();
}
}, files, params);
RequestQueue queue = Volley.newRequestQueue(this);
queue.add(multipartRequest);
Pour la postérité, je ne voyais pas okhttp mentionné. article similaire.
Fondamentalement, vous construisez le corps en utilisant un MultipartBody.Builder, puis postez ceci dans une requête.
Exemple de Kotlin:
val body = MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart(
"file",
file.getName(),
RequestBody.create(MediaType.parse("image/png"), file)
)
.addFormDataPart("timestamp", Date().time.toString())
.build()
val request = Request.Builder()
.url(url)
.post(body)
.build()
httpClient.newCall(request).enqueue(object : okhttp3.Callback {
override fun onFailure(call: Call?, e: IOException?) {
...
}
override fun onResponse(call: Call?, response: Response?) {
...
}
})
Vous pouvez vous utiliser GentleRequest, qui est une bibliothèque légère pour faire des requêtes http (DISCLAIMER: Je suis l'auteur):
Connections connections = new HttpConnections();
Binary binary = new PacketsBinary(new
BufferedInputStream(new FileInputStream(file)),
file.length());
//Content-Type is set to multipart/form-data; boundary=
//{generated by multipart object}
MultipartForm multipart = new HttpMultipartForm(
new HttpFormPart("user", "aplication/json",
new JSONObject().toString().getBytes()),
new HttpFormPart("java", "java.png", "image/png",
binary.content()));
Response response = connections.response(new
PostRequest(url, multipart));
if (response.hasSuccessCode()) {
byte[] raw = response.body().value();
String string = response.body().stringValue();
JSONOBject json = response.body().jsonValue();
} else {
}
Ne hésitez pas à le vérifier: https://github.com/Iprogrammerr/Gentle-Request
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
