Pourquoi volley réponse de la chaîne de l'utilisation d'un encodage différent de celui dans les en-têtes de réponse?

Ces deux types de demande d'appel HttpHeaderParser.parseCharset, qui est capable de déterminer le jeu de caractères à partir des en-têtes. Cependant, elle exige que l'en-tête être Content-Type, pas content-type: il est sensible à la casse. (Je ne suis pas sûr du comportement si vous utilisez la valeur par défaut HurlStack, il est possible que cela est un détail d'implémentation de différence avec le OkHttp de la pile.)

Solution 1: copie de la demande d'origine, mais remplacer manuellement le jeu de caractères

Solution 2: copie de la demande d'origine, mais la force de l'en-tête attendu pour exister

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;
import com.android.volley.toolbox.JsonRequest;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.UnsupportedEncodingException;
public class JsonUTF8Request extends JsonRequest<JSONObject> {
public JsonUTF8Request(int method, String url, JSONObject jsonRequest,
Listener<JSONObject> listener, ErrorListener errorListener) {
super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(), listener,
errorListener);
}
@Override
protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
try {
//solution 1:
String jsonString = new String(response.data, "UTF-8");
//solution 2:
response.headers.put(HTTP.CONTENT_TYPE,
response.headers.get("content-type"));
String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
//
return Response.success(new JSONObject(jsonString),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (JSONException je) {
return Response.error(new ParseError(je));
}
}
}

Remplacer la Méthode parseNetworkResponse de la Request<T> Classe.

Vous pouvez le faire comme ceci:

/**
* A canned request for retrieving the response body at a given URL as a String.
*/
public class StringRequest extends Request<String> {
private final Listener<String> mListener;
/**
* the parse charset.
*/
private String charset = null;
/**
* Creates a new request with the given method.
*
* @param method the request {@link Method} to use
* @param url URL to fetch the string at
* @param listener Listener to receive the String response
* @param errorListener Error listener, or null to ignore errors
*/
public StringRequest(int method, String url, Listener<String> listener,
ErrorListener errorListener) {
super(method, url, errorListener);
mListener = listener;
}
/**
* Creates a new GET request.
*
* @param url URL to fetch the string at
* @param listener Listener to receive the String response
* @param errorListener Error listener, or null to ignore errors
*/
public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
this(Method.GET, url, listener, errorListener);
}
/**
* Creates a new GET request with the given Charset.
*
* @param url URL to fetch the string at
* @param listener Listener to receive the String response
* @param errorListener Error listener, or null to ignore errors
*/
public StringRequest(String url, String charset, Listener<String> listener, ErrorListener errorListener) {
this(Method.GET, url, listener, errorListener);
this.charset = charset;
}
@Override
protected void deliverResponse(String response) {
mListener.onResponse(response);
}
@Override
protected Response<String> parseNetworkResponse(NetworkResponse response) {
String parsed;
try {
if(charset != null) {
parsed = new String(response.data, charset);
} else {
parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
}
} catch (UnsupportedEncodingException e) {
parsed = new String(response.data);
}
return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}
/**
* @return the Parse Charset Encoding
*/
public String getCharset() {
return charset;
}
/**
* set the Parse Charset Encoding
* @param charset
*/
public void setCharset(String charset) {
this.charset = charset;
}
}

Merci @Simon Heinen. En fonction de votre réponse, j'ai écrit une fonction.

private void addEncodeing2Request(NetworkResponse response) {
try {
String type = response.headers.get(HTTP.CONTENT_TYPE);
if (type == null) {
//Content-Type:
Log.d("RVA", "content type was null");
type = TYPE_UTF8_CHARSET;
response.headers.put(HTTP.CONTENT_TYPE, type);
} else if (!type.contains("charset")) {
//Content-Type: text/plain;
Log.d("RVA", "charset was null, added encode utf-8");
type += ";" + TYPE_UTF8_CHARSET;
response.headers.put(HTTP.CONTENT_TYPE, type);
} else {
//nice! Content-Type: text/plain; charset=utf-8'
Log.d("RVA", "charset is " + type);
}
} catch (Exception e) {
e.printStackTrace();
}
}

Utilisation:

protected Response<String> parseNetworkResponse(NetworkResponse response) {
addEncodeing2Request(response);
return super.parseNetworkResponse(response);
}

En outre, remplacer getParamsEncoding() fonctionne également.

protected String getParamsEncoding() {
return "utf-8";
}