Envoyer un JSONArray requête POST avec android volley bibliothèque

Je voudrais envoyer et recevoir un Tableau Json avec le volley.
Maintenant, je peux recevoir un tableau et c'est ok, mais je ne sais pas comment envoyer une demande (Par exemple: avec la méthode post).

JsonArrayRequest arrayReq = new JsonArrayRequest(URL,
            new Listener<JSONArray>() {
}

OriginalL'auteur | 2015-02-22

 List<Map<String,String>> listMap =  new ArrayList<Map<String, String>>();
        Map<String,String> map  = new HashMap<String,String>();
        try {

            map.put("email", customer.getEmail());
            map.put("password",customer.getPassword());

        } catch (Exception e) {
            e.printStackTrace();
        }
        listMap.add(map);

        String url = PersonalConstants.BASE_URL+"/url";
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(
                Request.Method.POST, url, String.valueOf(new JSONArray(listMap)),
                new Response.Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject jsonObject) {
                        Log.d(App.TAG, jsonObject.toString());
                    }
                }, new Response.ErrorListener (){

            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Log.d(App.TAG,volleyError.toString());
            }
        }
        );
        App.getInstance().getmRequestQueue().add(jsonObjectRequest);

OriginalL'auteur vrbsm

1

Voici un exemple:
```
//Define the web service URL
final String URL = "http://www.someurl.com";

//POST params to be sent to the server
HashMap<String, String> params = new HashMap<String, String>();
params.put("name", "raha tamjid");

//Define the POST request
JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),
   new Response.Listener<JSONObject>() {
       @Override
       public void onResponse(JSONObject response) {
           try {
               VolleyLog.v("Response:%n %s", response.toString(4));
           } catch (JSONException e) {
               e.printStackTrace();
           }
       }
   }, new Response.ErrorListener() {
       @Override
       public void onErrorResponse(VolleyError error) {
           VolleyLog.e("Error: ", error.getMessage());
       }
   });

//Add the request object to the queue to be executed
ApplicationController.getInstance().addToRequestQueue(req);
```
Comment la demande de publication diffère, c'est qu'il faut un JSONObject comme paramètre.

EDIT 1:

Si vous avez Volley installé comme un projet de bibliothèque dans votre IDE, puis il suffit de définir un nouveau constructeur
```
public JsonArrayRequest(int method, String url, JSONObject jsonRequest,
    Listener<JSONArray> listener, ErrorListener errorListener) {
        super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(), listener, errorListener);
}
```
à l'intérieur de la classe JsonArrayRequest qui est présent dans la Volley code de la bibliothèque. Maintenant, vous pouvez l'utiliser pour créer JsonArrayRequest objets et les ajouter à la RequestQueue.

EDIT 2:

1. Obtenir le Volley projet de bibliothèque de ici. Télécharger le projet et le mettre en place dans votre IDE.

2. Faites la modification de la JsonRequest classe (qui se trouve dans com.android.volley.toolbox espace de noms) comme indiqué dans la EDIT 1.

3. Supprimer la volley.jar de la libs dossier de votre PROJET d'APPLICATION.

4. Maintenant, allez dans les Propriétés du Projet -> Android -> Bibliothèque et cliquez sur Ajouter. De là, sélectionnez le Volley projet. Clean & Reconstruire.

5. Maintenant, dans votre PROJET d'APPLICATION vous pouvez faire un POST JsonArrayRequest juste comme la façon dont nous faire un POST JsonObjectRequest et d'obtenir un JSONArray dans le Response.

je vous remercie . mais je veux obtenir un Tableau Json en réponse pas d'Objet Json .
voir édité répondre
avez-vous essayé ?
pas de . j'ai la volée '.fichier jar . comment faire, pouvez-vous me montrer ?merci
voir le fichier de réponse

OriginalL'auteur Y.S.

Créer une classe et d'étendre JsonArrayRequest ensuite remplacer

@Override
protected Map<String, String> getParams() throws AuthFailureError {
HashMap<String, String> params = new HashMap<String, String>();
params.put("name", "value");
return params;
}
and add a new constructor and in it call
super(Method.POST, url, null, listener, errorListener);
or use this class
public class PostJsonArrayRequest extends JsonRequest<JSONArray> {
/**
* Creates a new request.
* @param url URL to fetch the JSON from
* @param listener Listener to receive the JSON response
* @param errorListener Error listener, or null to ignore errors.
*/
public PostJsonArrayRequest(String url, Response.Listener<JSONArray> listener, Response.ErrorListener errorListener) {
super(Method.POST, url, null, listener, errorListener);
}
@Override
protected Map<String, String> getParams() throws AuthFailureError {
HashMap<String, String> params = new HashMap<String, String>();
params.put("name", "value");
return params;
}
@Override
protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {
try {
String jsonString =
new String(response.data, HttpHeaderParser.parseCharset(response.headers));
return Response.success(new JSONArray(jsonString),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (JSONException je) {
return Response.error(new ParseError(je));
}
}
}

OriginalL'auteur Andriya

Créer une nouvelle classe java nommée JsonArrayPostRequest maintenant, vous pouvez l'utiliser comme la précédente demande, il suffit de remplacer JSONArrayRequest avec JsonArrayPostRequest et de passer les paramètres corrects

public  class JsonArrayPostRequest extends Request<JSONArray>{  
private Map<String,String> mParam;  
private Listener<JSONArray>  mListener;  
public JsonArrayPostRequest(String url,Listener<JSONArray> listener, ErrorListener errorListener,Map param) {  
super(Request.Method.POST, url, errorListener);  
mListener=listener;  
mParam=param;   
}  
@Override  
protected Map<String, String> getParams() throws AuthFailureError {  
return mParam;  
}  
@Override  
protected Response<JSONArray> parseNetworkResponse(NetworkResponse response) {  
try {  
String jsonString =  
new String(response.data, HttpHeaderParser.parseCharset(response.headers));  
return Response.success(new JSONArray(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(JSONArray response) {  
mListener.onResponse(response);  
}  
}

UTILISATION:

JsonArrayPostRequest request = new JsonArrayPostRequest(URL,new Response.Listener<JSONArray>(),             
new Response.ErrorListener() ,params);

OriginalL'auteur Vinay Jaju

Vous devez vous connecter pour publier un commentaire.