Obtention de BasicNetwork.performRequest: Code de réponse inattendu 400 dans Volley

Question

Dans Mon activité, il vérifie les informations d'identification de l'utilisateur et renvoie l'ID de session et les informations connexes si elles sont valides. La méthode est POST. Le paramètre doit être envoyé en tant que JSON.

{ 
"params": { 
    "context": {}, 
    "db": "testing", 
    "login": "admin", 
    "password": "admin" 
    } 
} 

Alors je crée un JSONObject et de l'envoyer comme il est avec Header.I je reçois une réponse dans POSTMAN.But ce que j'obtiens l'erreur quand je l'appelle comme is.Can quelqu'un me aider dans ce domaine?

private void volleyLogin() throws JSONException { 
     mProgressView.setVisibility(View.VISIBLE); 
     JSONObject one = new JSONObject(); 
     one.put("context",new JSONObject()); 
     one.put("db","testing"); 
     one.put("login","admin"); 
     one.put("password","admin"); 
     JSONObject params = new JSONObject(); 
     params.put("params",one); 
     HashMap<String, String> header = new HashMap<String, String>(); 
     header.put("Content-Type", "application/json; charset=utf-8"); 
     RequestQueue requestQueue = Volley.newRequestQueue(this); 
     CustomRequest jsObjRequest = new CustomRequest(Request.Method.POST, 
       ApiConstants.URL_AUTHENTICATE,params,header, new Response.Listener<JSONObject>() { 

      @Override 
      public void onResponse(JSONObject response) { 
      System.out.println("Response"+response); 
      } 
     }, 
       new Response.ErrorListener() { 
        @Override 
        public void onErrorResponse(VolleyError error) { 
         System.out.println("VolleyError"+error); 

        } 
       } 

     ); 
     jsObjRequest.setRetryPolicy(new DefaultRetryPolicy(
       (int) TimeUnit.SECONDS.toMillis(120), 
       DefaultRetryPolicy.DEFAULT_MAX_RETRIES, 
       DefaultRetryPolicy.DEFAULT_BACKOFF_MULT)); 
     System.out.println("jsObjRequest"+jsObjRequest); 
     requestQueue.add(jsObjRequest); 
    } 

Voici la demande personnalisée classe

public class CustomRequest extends Request<JSONObject> { 

    private Response.Listener<JSONObject> listener; 

    private JSONObject jsonObjectParams; 
    private Map<String, String> headers; 

    public CustomRequest(int method,String url, JSONObject jsonObjectParams,Map<String, String> headers, 
         Response.Listener<JSONObject> reponseListener, Response.ErrorListener errorListener) { 
     super(method, url, errorListener); 
     this.listener = reponseListener; 
     this.jsonObjectParams = jsonObjectParams; 
     this.headers= headers; 
     System.out.println("method"+method); 
     System.out.println("url"+url); 
     System.out.println("jsonObjectParams"+jsonObjectParams); 


    } 

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

    @Override 
    protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) { 
     try { 
      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)); 
     } 
    } 

    @Override 
    protected void deliverResponse(JSONObject response) { 
     // TODO Auto-generated method stub 
     listener.onResponse(response); 
    } 

    @Override 
    protected VolleyError parseNetworkError(VolleyError volleyError) { 

     if(volleyError.networkResponse != null && volleyError.networkResponse.data != null){ 
      VolleyError error = new VolleyError(new String(volleyError.networkResponse.data)); 
      volleyError = error; 
     } 
     return volleyError; 
    } 

} 

Answer 1

Vous pouvez essayer quelque chose comme ceci:

Créer une VolleyDispatcher de classe Singletone, qui détient le RequestQueue de volley.

public RequestQueue getRequestQueue() { 
    if (requestQueue == null) { 
     // getApplicationContext() is key, it keeps you from leaking the 
     // Activity or BroadcastReceiver if someone passes one in. 
     requestQueue = Volley.newRequestQueue(mContext.getApplicationContext()); 
    } 

    return requestQueue; 
} 

/** 
* Recreates the request queue using username/password https auth. 
*/ 
public void recreateRequestQueue() { 
    if (!AppUtil.isEmpty(AppConstants.USERNAME) && !AppUtil.isEmpty(AppConstants.PASSWORD)) {//check if a user is logged in so that the https auth can be created if necessary 
     if (requestQueue != null) { 
      requestQueue.stop(); 
      requestQueue = null; 
     } 

     requestQueue = Volley.newRequestQueue(mContext.getApplicationContext(), new HurlCustomStack()); 
    } 

} 

public <T> void addToRequestQueue(Request<T> req) { 
    getRequestQueue().add(req); 
} 

Appel recreateRequestQueue avant de faire toute demande volée

Mettre en oeuvre la coutume HurlStack

public class HurlCustomStack extends HurlStack { 

    @Override 
    protected HttpURLConnection createConnection(URL url) throws IOException { 
     // Workaround for the M release HttpURLConnection not observing the 
     // HttpURLConnection.setFollowRedirects() property. 
     // https://code.google.com/p/android/issues/detail?id=194495 
//  connection.setInstanceFollowRedirects(HttpURLConnection.getFollowRedirects()); 

     return HttpUrlConnectionHelper.getInstance().createHttpUrlConnection(url); 
    } 
} 

Et la méthode de création de client:

public HttpURLConnection createHttpUrlConnection(URL url) throws IOException { 
     Log.d(TAG, "Create http url connection with url : " + url.toString()); 

     HttpURLConnection httpConnection = null; 
     if ("https".equalsIgnoreCase(url.getProtocol())) { 
      HttpsURLConnection https = (HttpsURLConnection) url.openConnection(); 
      https.setHostnameVerifier(DO_NOT_VERIFY); 
      httpConnection = https; 
     } else { 
      httpConnection = (HttpURLConnection) url.openConnection(); 
     } 

     httpConnection.setReadTimeout(TIMEOUT); 
     httpConnection.setConnectTimeout(TIMEOUT); 
     String basicAuth = "Basic " + new String(Base64.encode((AppConstants.USERNAME + ":" + AppConstants.PASSWORD).getBytes(), Base64.NO_WRAP)); 
     httpConnection.setRequestProperty("Authorization", basicAuth); 
     httpConnection.setRequestProperty("Accept-Language", Locale.getDefault().getLanguage()); 

     return httpConnection; 
    } 

Alors maintenant, chaque fois que vous voulez faire une demande, il suffit d'utiliser la méthode addToRequestQueue dans le VolleyDispatcher classe.