वॉली - पोस्ट / जीईटी पैरामीटर

Question 1

मैंने वॉली के बारे में Google IO 2013 सत्र देखा और मैं वॉली पर स्विच करने पर विचार कर रहा हूं। क्या वोले अनुरोध करने के लिए POST / GET मापदंडों को जोड़ने का समर्थन करता है? यदि हाँ, तो मैं यह कैसे कर सकता हूँ?

Question 2

आपके अनुरोध वर्ग (जो अनुरोध का विस्तार करता है) में, getParams () विधि को ओवरराइड करें। आप हेडर के लिए भी ऐसा ही करेंगे, बस गेटहेडर्स () को ओवरराइड करें।

यदि आप PostWithBody में TestRequest.java में वॉली परीक्षणों को देखते हैं, तो आपको एक उदाहरण मिलेगा। यह कुछ इस तरह चलता है

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 = new HashMap<String, String>();
        mParams.put("paramOne", param1);
        mParams.put("paramTwo", param2);

    }

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

इवान चार्लटन एक त्वरित उदाहरण परियोजना बनाने के लिए पर्याप्त था जो हमें बताए कि वॉली का उपयोग कैसे करें। https://github.com/evancharlton/folly/

Question 3

GET मापदंडों के लिए दो विकल्प हैं:

पहला : जैसा कि आप केवल स्ट्रिंग का उपयोग कर सकते हैं और उनके मान के साथ पैरामीटर प्लेसहोल्डर्स को प्रतिस्थापित कर सकते हैं प्रश्न के एक टिप्पणी में सुझाव दिया गया है:

String uri = String.format("http://somesite.com/some_endpoint.php?param1=%1$s&param2=%2$s",
                           num1,
                           num2);

StringRequest myReq = new StringRequest(Method.GET,
                                        uri,
                                        createMyReqSuccessListener(),
                                        createMyReqErrorListener());
queue.add(myReq);

जहाँ num1 और num2 स्ट्रिंग वैरिएबल होते हैं जिनमें आपके मान होते हैं।

दूसरा : यदि आप नए बाहरी HttpClient (उदाहरण के लिए 4.2.x) का उपयोग कर रहे हैं, तो आप अपने Uri के निर्माण के लिए URIBuilder का उपयोग कर सकते हैं। लाभ यह है कि यदि आपके यूआरआई स्ट्रिंग में पहले से ही पैरामीटर हैं, तो इसे पास करना आसान होगा URIBuilderऔर फिर ub.setQuery(URLEncodedUtils.format(getGetParams(), "UTF-8"));अपने अतिरिक्त मापदंडों को जोड़ने के लिए उपयोग करें। इस तरह आप "अगर?" यूआरआई में पहले से ही जोड़ा जाता है या कुछ और याद करने के लिए और इस तरह संभावित त्रुटियों के लिए एक स्रोत को समाप्त करने के लिए जोड़ा जाता है।

POST मापदंडों के लिए शायद कभी-कभी ऐसा करने के लिए स्वीकृत उत्तर की तुलना में आसान होगा:

StringRequest myReq = new StringRequest(Method.POST,
                                        "http://somesite.com/some_endpoint.php",
                                        createMyReqSuccessListener(),
                                        createMyReqErrorListener()) {

    protected Map<String, String> getParams() throws com.android.volley.AuthFailureError {
        Map<String, String> params = new HashMap<String, String>();
        params.put("param1", num1);
        params.put("param2", num2);
        return params;
    };
};
queue.add(myReq);

उदाहरण के लिए सिर्फ getParams()विधि को ओवरराइड करना ।

आप एक कार्यकारी उदाहरण (कई अन्य बुनियादी वॉली उदाहरणों के साथ) एंडोरिड वॉली उदाहरण परियोजना में पा सकते हैं ।

Question 4

CustomRequest वॉली के JSONObjectRequest को हल करने का एक तरीका है StringRequest

यहाँ सहायक वर्ग है जो परम को जोड़ने की अनुमति देता है:

    import java.io.UnsupportedEncodingException;
    import java.util.Map;    
    import org.json.JSONException;
    import org.json.JSONObject;    
    import com.android.volley.NetworkResponse;
    import com.android.volley.ParseError;
    import com.android.volley.Request;
    import com.android.volley.Response;
    import com.android.volley.Response.ErrorListener;
    import com.android.volley.Response.Listener;
    import com.android.volley.toolbox.HttpHeaderParser;

    public class CustomRequest extends Request<JSONObject> {

    private Listener<JSONObject> listener;
    private Map<String, String> params;

    public CustomRequest(String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(Method.GET, url, errorListener);
        this.listener = reponseListener;
        this.params = params;
    }

    public CustomRequest(int method, String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.listener = reponseListener;
        this.params = params;
    }

    protected Map<String, String> getParams()
            throws com.android.volley.AuthFailureError {
        return params;
    };

    @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);
    }

}

ग्रीनचिउ को धन्यवाद

Question 5

यह सहायक वर्ग GET और POST अनुरोधों के लिए मापदंडों का प्रबंधन करता है:

import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;    

import org.json.JSONException;
import org.json.JSONObject;

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;

public class CustomRequest extends Request<JSONObject> {
    private int mMethod;
    private String mUrl;
    private Map<String, String> mParams;
    private Listener<JSONObject> mListener;

    public CustomRequest(int method, String url, Map<String, String> params,
            Listener<JSONObject> reponseListener, ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mMethod = method;
        this.mUrl = url;
        this.mParams = params;
        this.mListener = reponseListener;
    }

@Override
public String getUrl() {
    if(mMethod == Request.Method.GET) {
        if(mParams != null) {
            StringBuilder stringBuilder = new StringBuilder(mUrl);
            Iterator<Map.Entry<String, String>> iterator = mParams.entrySet().iterator();
            int i = 1;
            while (iterator.hasNext()) {
                Map.Entry<String, String> entry = iterator.next();
                if (i == 1) {
                    stringBuilder.append("?" + entry.getKey() + "=" + entry.getValue());
                } else {
                    stringBuilder.append("&" + entry.getKey() + "=" + entry.getValue());
                }
                iterator.remove(); // avoids a ConcurrentModificationException
                i++;
            }
            mUrl = stringBuilder.toString();
        }
    }
    return mUrl;
}

    @Override
    protected Map<String, String> getParams()
            throws com.android.volley.AuthFailureError {
        return mParams;
    };

    @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
        mListener.onResponse(response);
    }
}

Question 6

जीईटी के मापदंडों से निपटना मैंने एंड्रिया मोतो के समाधान पर आधारित किया। समस्या यह थी कि वॉली ने GetUrlकई बार फोन किया और उनके समाधान ने एक Iterator का उपयोग करते हुए, मूल मैप ऑब्जेक्ट को नष्ट कर दिया। बाद की वॉली आंतरिक कॉलों में एक खाली परमेस ऑब्जेक्ट था।

मैंने मापदंडों के एनकोड को भी जोड़ा।

यह एक इनलाइन उपयोग (कोई उपवर्ग) नहीं है।

public void GET(String url, Map<String, String> params, Response.Listener<String> response_listener, Response.ErrorListener error_listener, String API_KEY, String stringRequestTag) {
    final Map<String, String> mParams = params;
    final String mAPI_KEY = API_KEY;
    final String mUrl = url;

    StringRequest stringRequest = new StringRequest(
            Request.Method.GET,
            mUrl,
            response_listener,
            error_listener
    ) {
        @Override
        protected Map<String, String> getParams() {
            return mParams;
        }

        @Override
        public String getUrl() {
            StringBuilder stringBuilder = new StringBuilder(mUrl);
            int i = 1;
            for (Map.Entry<String,String> entry: mParams.entrySet()) {
                String key;
                String value;
                try {
                    key = URLEncoder.encode(entry.getKey(), "UTF-8");
                    value = URLEncoder.encode(entry.getValue(), "UTF-8");
                    if(i == 1) {
                        stringBuilder.append("?" + key + "=" + value);
                    } else {
                        stringBuilder.append("&" + key + "=" + value);
                    }
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                i++;

            }
            String url = stringBuilder.toString();

            return url;
        }

        @Override
        public Map<String, String> getHeaders() {
            Map<String, String> headers = new HashMap<>();
            if (!(mAPI_KEY.equals(""))) {
                headers.put("X-API-KEY", mAPI_KEY);
            }
            return headers;
        }
    };

    if (stringRequestTag != null) {
        stringRequest.setTag(stringRequestTag);
    }

    mRequestQueue.add(stringRequest);
}

यह फ़ंक्शन APIKEY को पारित करने के लिए हेडर का उपयोग करता है और इसके पूरा होने से पहले इसे रद्द करने के लिए उपयोगी TAG सेट करता है।

उम्मीद है की यह मदद करेगा।

Question 7

यह आपकी मदद कर सकता है ...

private void loggedInToMainPage(final String emailName, final String passwordName) {

    String tag_string_req = "req_login";
    StringRequest stringRequest = new StringRequest(Request.Method.POST, "http://localhost/index", new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            Log.d(TAG, "Login Response: " + response.toString());
            try {
                JSONObject jsonObject = new JSONObject(response);
                Boolean error = jsonObject.getBoolean("error");
                if (!error) {

                    String uid = jsonObject.getString("uid");
                    JSONObject user = jsonObject.getJSONObject("user");
                    String email = user.getString("email");
                    String password = user.getString("password");


                    session.setLogin(true);
                    Intent intent = new Intent(getApplicationContext(), MainActivity.class);
                    startActivity(intent);
                    finish();
                    Toast.makeText(getApplicationContext(), "its ok", Toast.LENGTH_SHORT).show();
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }

        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError volleyError) {
            System.out.println("volley Error .................");
        }
    }) {
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> params = new HashMap<String, String>();
            params.put("tag", "login");
            params.put("email", emailName);
            params.put("password", passwordName);
            return params;
        }
    };


    MyApplication.getInstance().addToRequestQueue(stringRequest,tag_string_req);
}

Question 8

भविष्य के पाठकों के लिए

मुझे वॉली के साथ काम करना बहुत पसंद है । विकास के समय को बचाने के लिए मैंने अपनी परियोजना के साथ वॉली को सेटअप करने के लिए छोटे काम के पुस्तकालय Gloxey Netwok प्रबंधक को लिखने की कोशिश की । इसमें JSON पार्सर और विभिन्न अन्य विधियां शामिल हैं जो नेटवर्क उपलब्धता की जांच करने में मदद करती हैं।

उपयोग ConnectionManager.classके लिए विभिन्न तरीकों, जिसमें वॉली स्ट्रिंग और वॉली JSON का अनुरोध उपलब्ध हैं। आप हेडर के साथ या उसके बिना GET, PUT, POST, DELETE के अनुरोध कर सकते हैं । आप यहाँ पूर्ण प्रलेखन पढ़ सकते हैं ।

बस इस लाइन को अपनी gradle फ़ाइल में रखें।

  dependencies { 

       compile 'io.gloxey.gnm:network-manager:1.0.1'
   }

वॉली StringRequest

विधि GET (हेडर के बिना)

    ConnectionManager.volleyStringRequest(context, isDialog, progressDialogView, requestURL, volleyResponseInterface);

कैसे इस्तेमाल करे?

     Configuration                Description

     Context                      Context 
     isDialog                     If true dialog will appear, otherwise not.
     progressView                 For custom progress view supply your progress view id and make isDialog true. otherwise pass null. 
     requestURL                   Pass your API URL.  
     volleyResponseInterface      Callback for response.

उदाहरण

    ConnectionManager.volleyStringRequest(this, false, null, "url", new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */
    }

    @Override
     public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
    }
});

वॉली StringRequest

विधि POST / PUT / DELETE (हेडर के बिना)

    ConnectionManager.volleyStringRequest(context, isDialog, progressDialogView, requestURL, requestMethod, params, volleyResponseInterface);

उदाहरण

Use Method : Request.Method.POST
             Request.Method.PUT
             Request.Method.DELETE

Your params : 

HashMap<String, String> params = new HashMap<>();
params.put("param 1", "value");
params.put("param 2", "value");

ConnectionManager.volleyStringRequest(this, true, null, "url", Request.Method.POST, params, new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */
    }

    @Override
    public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
    }
});

बक्शीश

Gloxey JSON पार्सर

अपने एपीआई प्रतिक्रिया को पार्स करने के लिए ग्लॉक्सी जोंस पार्सर का उपयोग करने के लिए स्वतंत्र महसूस करें।

  YourModel yourModel = GloxeyJsonParser.getInstance().parse(stringResponse, YourModel.class);

उदाहरण

ConnectionManager.volleyStringRequest(this, false, null, "url", new VolleyResponse() {
    @Override
    public void onResponse(String _response) {

        /**
         * Handle Response
         */

         try {

          YourModel yourModel = GloxeyJsonParser.getInstance().parse(_response, YourModel.class);

            } catch (Exception e) {
                e.printStackTrace();
            }

    }

    @Override
     public void onErrorResponse(VolleyError error) {

        /**
         * handle Volley Error
         */
         if (error instanceof TimeoutError || error instanceof NoConnectionError) {

                showSnackBar(parentLayout, getString(R.string.internet_not_found), getString(R.string.retry), new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {

                     //handle retry button

                    }
                });

            } else if (error instanceof AuthFailureError) {
            } else if (error instanceof ServerError) {
            } else if (error instanceof NetworkError) {
            } else if (error instanceof ParseError) {
            }

    }

    @Override
    public void isNetwork(boolean connected) {

        /**
         * True if internet is connected otherwise false
         */
          if (!connected) {
                showSnackBar(parentLayout, getString(R.string.internet_not_found), getString(R.string.retry), new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        //Handle retry button
                    }
                });
    }
});


     public void showSnackBar(View view, String message) {
            Snackbar.make(view, message, Snackbar.LENGTH_LONG).show();
     }

     public void showSnackBar(View view, String message, String actionText, View.OnClickListener onClickListener) {
            Snackbar.make(view, message, Snackbar.LENGTH_LONG).setAction(actionText, onClickListener).show();
     }

Question 9

POSTपैरामीटर प्रदान करने के लिए अपने पैरामीटर को कंस्ट्रक्टर के रूप JSONObject में भेजें JsonObjectRequest। तीसरा पैरामीटर JSONObjectअनुरोध बॉडी में उपयोग किए जाने वाले को स्वीकार करता है ।

JSONObject paramJson = new JSONObject();

paramJson.put("key1", "value1");
paramJson.put("key2", "value2");


JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.POST,url,paramJson,
    new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {

        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {

        }
    });
requestQueue.add(jsonObjectRequest);