codice di stato HTTP GET per le richieste di successo con Volley

Question

sto recuperando il contenuto di un indirizzo web non valido con tiro al volo, vale a dire: http://www.gigd32fdsu.com Questo è il mio codice di prova:

// Instantiate the RequestQueue. 
RequestQueue queue = Volley.newRequestQueue(this); 
final String url = "http://www.gigd32fdsu.com"; 

// Request a string response from the provided URL. 
StringRequest stringRequest = new StringRequest(Request.Method.GET, url, 
new Response.Listener() { 
    @Override 
    public void onResponse(Object response) { 
     // Display the first 500 characters of the response string. 
     mTextView.setText("Response is: " + response.toString().substring(0, 500)); 
    } 
}, new Response.ErrorListener() { 
    @Override 
    public void onErrorResponse(VolleyError error) { 
     mTextView.setText("That didn't work! " + error.networkResponse.statusCode); 
    } 
}); 
// Add the request to the RequestQueue. 
queue.add(stringRequest); 

Quando eseguo questo codice ricevo il callback onResponse (String) con una pagina di errore dal mio ISP. Come posso leggere il codice di stato HTTP per rilevare che la visualizzazione web non è corretta?

Grazie

Answer 1

Basta sovrascrivere il metodo parseNetworkResponse poi prendere il valore statusCode.

public class StrImplRequest extends StringRequest { 
    @Override 
    protected Response<String> parseNetworkResponse(NetworkResponse response) { 
     // take the statusCode here. 
     response.statusCode; 
     return super.parseNetworkResponse(response); 
    } 
} 

Answer 2

Farò più completa la risposta di VinceStyling. Ti dirò cosa faccio.

Dopo aver sovrascritto questo metodo, salvare lo statusCode nella classe.

 @Override 
     protected Response<String> parseNetworkResponse(NetworkResponse response) { 
      statusCode=response.statusCode; 
      return super.parseNetworkResponse(response); 
     } 

Successivamente, è necessario confrontarlo con le costanti HttpURLConnection per agire di conseguenza. Per esempio:

  int statusCode=webService.getStatusCode(); 
      switch (statusCode){ 
       case HttpURLConnection.HTTP_OK: 
        //do stuff 
        break; 
       case HttpURLConnection.HTTP_NOT_FOUND: 
        //do stuff 
        break; 
       case HttpURLConnection.HTTP_INTERNAL_ERROR: 
        //do stuff 
        break; 
      } 

Answer 3

soluzione semplice è quella di ignorare parseNetworkResponse in makeStringReq(), senza bisogno di un'altra classe:

private void makeStringReq() { 
    showProgressDialog(); 

    StringRequest strReq = new StringRequest(Method.GET, 
      Const.URL_STRING_REQ, 
      new Response.Listener<String>() { 
       @Override 
       public void onResponse(String response) { 
        Log.d(TAG, response.toString()); 
        msgResponse.setText(response.toString()); 
        hideProgressDialog(); 

       } 
      }, 
      new Response.ErrorListener() { 
       @Override 
       public void onErrorResponse(VolleyError error) { 
        VolleyLog.d(TAG, "Error: " + error.getMessage()); 
        hideProgressDialog(); 
       } 
      }) { 

     @Override 
     protected Response<String> parseNetworkResponse(NetworkResponse response) { 
      int mStatusCode = response.statusCode; 
      return super.parseNetworkResponse(response); 
     } 
    }; 

    // Adding request to request queue 
    AppController.getInstance().addToRequestQueue(strReq, tag_string_req); 

} 

Answer 4

risposta @VinceStyling s' è ok, o è possibile estendere Richiesta di classe e fa 'ciò che vuoi. Per esempio,

ServerStatusRequestObject extends Request { 

    private final Response.Listener mListener; 
    private String mBody = ""; 
    private String mContentType; 

    public ServerStatusRequestObject(int method, 
            String url, 
            Response.Listener listener, 
            Response.ErrorListener errorListener) { 

     super(method, url, errorListener); 
     mListener = listener; 
     mContentType = "application/json"; 

     if (method == Method.POST) { 
      RetryPolicy policy = new DefaultRetryPolicy(5000, 0, 5); 
      setRetryPolicy(policy); 
     } 
    } 

    @Override 
    protected Response parseNetworkResponse(NetworkResponse response) { 
     return Response.success(response.statusCode, HttpHeaderParser.parseCacheHeaders(response)); 
    } 

    @Override 
    protected void deliverResponse(Object response) { 
     if (mListener != null) { 
      mListener.onResponse(response); 
     } 
    } 

    @Override 
    public byte[] getBody() throws AuthFailureError { 
     return mBody.getBytes(); 
    } 

    @Override 
    public String getBodyContentType() { 
     return mContentType; 
    } 

    @Override 
    public int compareTo(Object another) { 
     return 0; 
    } 

poi nel vostro gestore di risposta, è ancora possibile ricevere l'intero messaggio per server. Provalo.