android - tramites - ¿Volley no llama a getParams para mi solicitud personalizada?

mbeca mec

Question

¿Volley agrega automáticamente mis parámetros GET a la URL? Para mí no está funcionando así y también al buscar fuentes, simplemente no puedo encontrar ninguna llamada del método getParams. ¿Debo construir la URL yo mismo? No es problema en absoluto, solo pensé que cuando hay un método como getParams, podría hacer eso por mí :)

ACTUALIZAR: A continuación está mi código ...

public class BundleRequest extends com.android.volley.Request<Bundle>{

    private String token;
    private OnAuthTokenValidatorResponseListener mListener;
    private final Map<String, String> mParams =  new HashMap<String, String>();;


    public BundleRequest(int method, String url,  Response.ErrorListener listener) {
        super(method, url, listener);
    }

    public BundleRequest(int method, String url,OnAuthTokenValidatorResponseListener providedListener,  Response.ErrorListener listener, String token) {
        super(method, url, listener);
        this.token = token;
        mListener = providedListener;
        mParams.put(AuthenticatorConfig.TOKEN_VALIDATION_PARAMNAME, token);

    }

    @Override
    public Map<String, String> getParams() throws AuthFailureError {
        return mParams;
    }




    @Override
    protected Response<Bundle> parseNetworkResponse(NetworkResponse httpResponse) {
        switch (httpResponse.statusCode) {
            case AuthTokenValidator.TOKEN_VALID_RESPONSE_CODE:
                //token is ok
                JSONObject response;
                try {
                        response = new JSONObject(new String(httpResponse.data, HttpHeaderParser.parseCharset(httpResponse.headers)));
                        Bundle userDataResponse = new Bundle();
                        userDataResponse.putInt("responseCode", httpResponse.statusCode);
                        userDataResponse.putString("username", response.getString("user_id"));
                        userDataResponse.putString("email", response.getString("user_email"));
                        userDataResponse.putString("expiresIn", response.getString("expires_in"));
                        userDataResponse.putString("scope", response.getJSONArray("scope").getString(0));
                        userDataResponse.putString("token", token);
                    return Response.success(userDataResponse, HttpHeaderParser.parseCacheHeaders(httpResponse));
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    return Response.error(new VolleyError("Unsupported encoding"));


                } catch (JSONException e) {
                    e.printStackTrace();
                    return Response.error(new VolleyError("Problem while parsing JSON"));
                }




            case AuthTokenValidator.TOKEN_INVALID_RESPONSE_CODE:
                //token is not valid
                mListener.onValidatorResponse(httpResponse.statusCode);
                try {
                    mListener.onValidatorResponse(parseOnErrorResponse(new String(httpResponse.data, HttpHeaderParser.parseCharset(httpResponse.headers))));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }

            default:
                return Response.error(new VolleyError("Error status code:" + httpResponse.statusCode));

        }
    }

    protected int parseOnErrorResponse(String responseBody) {
        try {
            JSONObject response = new JSONObject(responseBody);
            String moreInfo = response.getString("more_info");
            if (moreInfo.equals("Token was not recognised")) {
                return AuthTokenValidator.TOKEN_WAS_NOT_RECOGNISED;
            } else if (moreInfo.equals("Token has expired")) {
                return AuthTokenValidator.TOKEN_HAS_EXPIRED;
            } else if (moreInfo.equals("Client doesn''t exist anymore")) {
                return AuthTokenValidator.CLIENT_DOES_NOT_EXIST_ANYMORE;
            } else if (moreInfo.equals("Client is locked")) {
                return AuthTokenValidator.CLIENT_IS_LOCKED;
            } else {
                return AuthTokenValidator.UNKNOWN_ERROR;
            }

        } catch (JSONException e) {
            e.printStackTrace();
            return AuthTokenValidator.UNKNOWN_ERROR;
        }

    }

    @Override
    protected void deliverResponse(Bundle response) {
        mListener.onGetUserDataResponse(response);
    }
}

En realidad, el parámetro params ahora es redundante

Answer 1

Prueba esto,

public class LoginRequest extends Request<String> {

    // ... other methods go here

    private Map<String, String> mParams;

    public LoginRequest(String param1, String param2, Listener<String> listener, ErrorListener errorListener) {
        super(Method.POST, "http://test.url", errorListener);
        mListener = listener;
        mParams.put("paramOne", param1);
        mParams.put("paramTwo", param2);

    }

    @Override
    public Map<String, String> getParams() {
        return mParams;
    }
}

Ver este ejemplo también,

https://github.com/evancharlton/folly/

Answer 2

getParams() no se llama en el método GET, por lo que parece que tendrá que agregarlo a la URL antes de enviar la solicitud.

Mira el JavaDoc:

Devuelve un Mapa de parámetros que se utilizará para una solicitud POST o PUT.

Puede lanzar {@link AuthFailureError} ya que se puede requerir autenticación para proporcionar estos valores.

Tenga en cuenta que puede anular directamente {@link #getBody ()} los datos personalizados.

@throws AuthFailureError en caso de error de autenticación

Answer 3

En cuanto a la respuesta de Itai Hanski , este es un ejemplo para implementar eso:

 for(String key: params.keySet()) {
   url += "&"+key+"="+params.get(key);
 }