web-dev-qa-db-fra.com

Pourquoi la chaîne de réponse de volley utilise-t-elle un codage différent de celui des en-têtes de réponse?

Lorsque vous effectuez une demande de volée (StringRequest ou JsonObjectRequest), à l'aide de la pile OkHttp, le codage de la chaîne de réponse est défini sur ISO-8995-1, qui est le codage par défaut. La réponse a un en-tête: content-type=text/html; charset=utf-8, qui doit être détecté. Pourquoi pas?

androidcharacter-encodingandroid-volley
18
mjibson

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

Solution 1: copiez le type de demande d'origine, mais remplacez manuellement le jeu de caractères

Solution 2: copiez le type de demande d'origine, mais forcez l'en-tête attendu à 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));
        }
    }
}
34
mjibson

Tout d'abord merci beaucoup @mjibson pour les 2 solutions que vous avez publiées ici, j'ai eu un problème similaire, dans mon cas, le type de contenu manquait toujours, tout comme les éléments suivants:

    protected static final String TYPE_UTF8_CHARSET = "charset=UTF-8";

    @Override
    protected Response<String> parseNetworkResponse(
            NetworkResponse response) {
        try {
            String type = response.headers.get(HTTP.CONTENT_TYPE);
            if (type == null) {
                Log.d(LOG_TAG, "content type was null");
                type = TYPE_UTF8_CHARSET;
                response.headers.put(HTTP.CONTENT_TYPE, type);
            } else if (!type.contains("UTF-8")) {
                Log.d(LOG_TAG, "content type had UTF-8 missing");
                type += ";" + TYPE_UTF8_CHARSET;
                response.headers.put(HTTP.CONTENT_TYPE, type);
            }
        } catch (Exception e) {
            //print stacktrace e.g.
        }
        return super.parseNetworkResponse(response);
    }

je voulais juste partager cela pour que d'autres rencontrent un problème similaire. il est également important de lire la méthode parseCharset dans https://Android.googlesource.com/platform/frameworks/volley/+/master/src/com/Android/volley/toolbox/HttpHeaderParser.Java to comprendre pourquoi cela fonctionne

12
Simon Heinen

Changez la méthode de GET en POST pour le support UTF-8

JsonObjectRequest jsonReq = new JsonObjectRequest(Method.POST,
            URL_FEED, null, new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    VolleyLog.d(TAG, "Response: " + response.toString());
                    Log.d("SHY", "Response: " + response.toString());
                    if (response != null) {
                        parseJsonFeed(response);
                    }
                }
            }, new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    VolleyLog.d(TAG, "Error: " + error.getMessage());
                }
            });

. . . .

3
Suyog Gunjal

Remplacez la méthode parseNetworkResponse de la Request<T> Classe.
Vous pouvez 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;
    }

}
3
Ligboy

Merci @Simon Heinen. Sur la base 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();
    }
}

Usage:

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

En outre, remplacer getParamsEncoding () peut également fonctionner.

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