Android
फ़ायर

परिचय

वाक्य - विन्यास

• RequestQueue queue = Volley.newRequestQueue (संदर्भ); // कतार को सेटअप करें
• अनुरोध अनुरोध = नया SomeKindOfRequestClass (Request.Method, स्ट्रिंग url, Response.Listener, Response.ErrorListener); // किसी प्रकार का अनुरोध सेटअप करें, प्रत्येक अनुरोध प्रकार के लिए सटीक प्रकार और तर्क बदल जाते हैं
• queue.add (अनुरोध); // कतार में अनुरोध जोड़ें; अनुरोध समाप्त होने पर उपयुक्त प्रतिक्रिया श्रोता को बुलाया जाएगा (या जो भी कारण से समाप्त हो)

टिप्पणियों

dependencies {
    ...
    compile 'com.android.volley:volley:1.0.0'
}

<uses-permission android:name="android.permission.INTERNET"/>

GET विधि का उपयोग करके मूल स्ट्रिंगरंग

final TextView mTextView = (TextView) findViewById(R.id.text);
...

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

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

एक अनुरोध रद्द करें

// assume a Request and RequestQueue have already been initialized somewhere above

public static final String TAG = "SomeTag";

// Set the tag on the request.
request.setTag(TAG);

// Add the request to the RequestQueue.
mRequestQueue.add(request);

// To cancel this specific request
request.cancel();

// ... then, in some future life cycle event, for example in onStop()
// To cancel all requests with the specified tag in RequestQueue
mRequestQueue.cancelAll(TAG);

NetworkImageView में कस्टम डिज़ाइन समय विशेषताएँ जोड़ना

कई अतिरिक्त विशेषताएं हैं जो वॉली NetworkImageView मानक ImageView जोड़ता है। हालाँकि, ये विशेषताएँ केवल कोड में सेट की जा सकती हैं। निम्नलिखित एक विस्तार वर्ग बनाने का एक उदाहरण है जो आपकी XML लेआउट फ़ाइल से विशेषताओं को NetworkImageView और उन्हें आपके लिए NetworkImageView उदाहरण पर लागू करेगा।

अपनी ~/res/xml निर्देशिका में, attrx.xml नामक एक फ़ाइल जोड़ें:

<resources>
    <declare-styleable name="MoreNetworkImageView">
        <attr name="defaultImageResId" format="reference"/>
        <attr name="errorImageResId" format="reference"/>
    </declare-styleable>
</resources>

अपनी परियोजना में एक नई कक्षा फ़ाइल जोड़ें:

package my.namespace;

import android.content.Context;
import android.content.res.TypedArray;
import android.support.annotation.NonNull;
import android.util.AttributeSet;

import com.android.volley.toolbox.NetworkImageView;

public class MoreNetworkImageView extends NetworkImageView {
    public MoreNetworkImageView(@NonNull final Context context) {
        super(context);
    }

    public MoreNetworkImageView(@NonNull final Context context, @NonNull final AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public MoreNetworkImageView(@NonNull final Context context, @NonNull final AttributeSet attrs, final int defStyle) {
        super(context, attrs, defStyle);

        final TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.MoreNetworkImageView, defStyle, 0);

        // load defaultImageResId from XML
        int defaultImageResId = attributes.getResourceId(R.styleable.MoreNetworkImageView_defaultImageResId, 0);
        if (defaultImageResId > 0) {
            setDefaultImageResId(defaultImageResId);
        }

        // load errorImageResId from XML
        int errorImageResId = attributes.getResourceId(R.styleable.MoreNetworkImageView_errorImageResId, 0);
        if (errorImageResId > 0) {
            setErrorImageResId(errorImageResId);
        }
    }
}

एक उदाहरण लेआउट फ़ाइल जिसमें कस्टम विशेषताओं का उपयोग दिखाया गया है:

<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView
  xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="wrap_content"
  android:layout_height="fill_parent">

  <my.namespace.MoreNetworkImageView
    android:layout_width="64dp"
    android:layout_height="64dp"
    app:errorImageResId="@drawable/error_img"
    app:defaultImageResId="@drawable/default_img"
    tools:defaultImageResId="@drawable/editor_only_default_img"/>
    <!-- 
      Note: The "tools:" prefix does NOT work for custom attributes in Android Studio 2.1 and 
      older at least, so in this example the defaultImageResId would show "default_img" in the 
      editor, not the "editor_only_default_img" drawable even though it should if it was 
      supported as an editor-only override correctly like standard Android properties.
    -->

</android.support.v7.widget.CardView>

JSON का अनुरोध करें

final TextView mTxtDisplay = (TextView) findViewById(R.id.txtDisplay);
ImageView mImageView;
String url = "http://ip.jsontest.com/";

final JsonObjectRequest jsObjRequest = new JsonObjectRequest
        (Request.Method.GET, url, null, new Response.Listener<JSONObject>() {    
    @Override
    public void onResponse(JSONObject response) {
        mTxtDisplay.setText("Response: " + response.toString());
    }
}, new Response.ErrorListener() {    
    @Override
    public void onErrorResponse(VolleyError error) {
        // ...
    }
});

requestQueue.add(jsObjRequest);

अपने अनुरोधों में कस्टम हेडर जोड़ना [उदाहरण के लिए बुनियादी अधिकार]

यदि आपको अपने वॉली अनुरोधों में कस्टम हेडर जोड़ने की आवश्यकता है, तो आप इसे आरंभीकरण के बाद नहीं कर सकते, क्योंकि हेडर एक निजी चर में सहेजे जाते हैं।

इसके बजाय, आपको getHeaders() Request.class विधि को ओवरराइड करने की आवश्यकता है:

new JsonObjectRequest(REQUEST_METHOD, REQUEST_URL, REQUEST_BODY, RESP_LISTENER, ERR_LISTENER) {
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        HashMap<String, String> customHeaders = new Hashmap<>();

        customHeaders.put("KEY_0", "VALUE_0");
        ...
        customHeaders.put("KEY_N", "VALUE_N");

        return customHeaders;
    }
};

मापदंडों की व्याख्या:

• REQUEST_METHOD - या तो REQUEST_METHOD Request.Method.* स्थिरांक।
• REQUEST_URL - आपके अनुरोध को भेजने के लिए पूरा URL।
• REQUEST_BODY - एक JSONObject जिसमें POST- बॉडी को भेजा जाना है (या अशक्त)।
• RESP_LISTENER - एक Response.Listener<?> RESP_LISTENER Response.Listener<?> ऑब्जेक्ट, जिसके onResponse(T data) विधि को सफल समापन कहा जाता है।
• ERR_LISTENER - एक Response.ErrorListener ERR_LISTENER वस्तु, जिसका onErrorResponse(VolleyError e) विधि असफल अनुरोध पर कहा जाता है।

यदि आप एक कस्टम अनुरोध बनाना चाहते हैं, तो आप इसमें हेडर भी जोड़ सकते हैं:

public class MyCustomRequest extends Request {
    ...
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        HashMap<String, String> customHeaders = new Hashmap<>();

        customHeaders.put("KEY_0", "VALUE_0");
        ...
        customHeaders.put("KEY_N", "VALUE_N");

        return customHeaders;
    }
    ...
}

वॉली एरर्स को संभालने के लिए हेल्पर क्लास

public class VolleyErrorHelper {
        /**
         * Returns appropriate message which is to be displayed to the user
         * against the specified error object.
         *
         * @param error
         * @param context
         * @return
         */

        public static String getMessage (Object error , Context context){
            if(error instanceof TimeoutError){
                return context.getResources().getString(R.string.timeout);
            }else if (isServerProblem(error)){
                return handleServerError(error ,context);

            }else if(isNetworkProblem(error)){
                return context.getResources().getString(R.string.nointernet);
            }
            return context.getResources().getString(R.string.generic_error);

        }

        private static String handleServerError(Object error, Context context) {

            VolleyError er = (VolleyError)error;
            NetworkResponse response = er.networkResponse;
            if(response != null){
                switch (response.statusCode){

                    case 404:
                    case 422:
                    case 401:
                        try {
                            // server might return error like this { "error": "Some error occured" }
                            // Use "Gson" to parse the result
                            HashMap<String, String> result = new Gson().fromJson(new String(response.data),
                                    new TypeToken<Map<String, String>>() {
                                    }.getType());

                            if (result != null && result.containsKey("error")) {
                                return result.get("error");
                            }

                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        // invalid request
                        return ((VolleyError) error).getMessage();

                    default:
                        return context.getResources().getString(R.string.timeout);
                }
            }

            return context.getResources().getString(R.string.generic_error);
        }

        private static boolean isServerProblem(Object error) {
            return (error instanceof ServerError || error instanceof AuthFailureError);
        }

        private static boolean isNetworkProblem (Object error){
            return (error instanceof NetworkError || error instanceof NoConnectionError);
        }

POST विधि के माध्यम से StringRequest का उपयोग कर रिमोट सर्वर प्रमाणीकरण

इस उदाहरण के लिए, मान लें कि हमारे पास POST अनुरोधों को संभालने के लिए एक सर्वर है, जिसे हम अपने एंड्रॉइड ऐप से बनाएंगे:

// User input data.
String email = "[email protected]";
String password = "123";

// Our server URL for handling POST requests.
String URL = "http://my.server.com/login.php";

// When we create a StringRequest (or a JSONRequest) for sending
// data with Volley, we specify the Request Method as POST, and 
// the URL that will be receiving our data.
StringRequest stringRequest = 
    new StringRequest(Request.Method.POST, URL, 
    new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            // At this point, Volley has sent the data to your URL
            // and has a response back from it. I'm going to assume
            // that the server sends an "OK" string.
            if (response.equals("OK")) {
                // Do login stuff.
            } else {
                // So the server didn't return an "OK" response.
                // Depending on what you did to handle errors on your
                // server, you can decide what action to take here.
            }
        }
    },
    new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {      
            // This is when errors related to Volley happen.
            // It's up to you what to do if that should happen, but
            // it's usually not a good idea to be too clear as to
            // what happened here to your users.
        }
    }) {
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            // Here is where we tell Volley what it should send in
            // our POST request. For this example, we want to send
            // both the email and the password. 
            
            // We will need key ids for our data, so our server can know
            // what is what.
            String key_email = "email";
            String key_password = "password";

            Map<String, String> map = new HashMap<String, String>();
            // map.put(key, value);
            map.put(key_email, email);
            map.put(key_password, password);
            return map;
        }
    };

    // This is a policy that we need to specify to tell Volley, what
    // to do if it gets a timeout, how many times to retry, etc.
    stringRequest.setRetryPolicy(new RetryPolicy() {
            @Override
            public int getCurrentTimeout() {
                // Here goes the timeout.
                // The number is in milliseconds, 5000 is usually enough,
                // but you can up or low that number to fit your needs.
                return 50000;
            }
            @Override
            public int getCurrentRetryCount() {
                // The maximum number of attempts.
                // Again, the number can be anything you need.
                return 50000;
            }
            @Override
            public void retry(VolleyError error) throws VolleyError {
                // Here you could check if the retry count has gotten
                // to the maximum number, and if so, send a VolleyError
                // message or similar. For the sake of the example, I'll 
                // show a Toast.  
                Toast.makeText(getContext(), error.toString(), Toast.LENGTH_LONG).show();
            }
    });
    
    // And finally, we create a Volley Queue. For this example, I'm using
    // getContext(), because I was working with a Fragment. But context could
    // be "this", "getContext()", etc.
    RequestQueue requestQueue = Volley.newRequestQueue(getContext());
    requestQueue.add(stringRequest);

} else { 
    // If, for example, the user inputs an email that is not currently
    // on your remote DB, here's where we can inform the user.
    Toast.makeText(getContext(), "Wrong email", Toast.LENGTH_LONG).show();
}

HTTP अनुरोधों के लिए वॉली का उपयोग करना

ऐप-स्तर build.gradle में ग्रेडल निर्भरता जोड़ें

compile 'com.android.volley:volley:1.0.0'

इसके अलावा, अपने ऐप के प्रकट होने के लिए android.permission.INTERNET अनुमति जोड़ें।

** अपने आवेदन में वॉली RequestQueue उदाहरण सिंगलटन बनाएं **

public class InitApplication extends Application {

private RequestQueue queue;
private static InitApplication sInstance;

private static final String TAG = InitApplication.class.getSimpleName();


@Override
public void onCreate() {
    super.onCreate();

    sInstance = this;

    Stetho.initializeWithDefaults(this);

}

public static synchronized InitApplication getInstance() {
    return sInstance;
}

public <T> void addToQueue(Request<T> req, String tag) {
    req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);
    getQueue().add(req);
}

public <T> void addToQueue(Request<T> req) {
    req.setTag(TAG);
    getQueue().add(req);
}

public void cancelPendingRequests(Object tag) {
    if (queue != null) {
        queue.cancelAll(tag);
    }
}

public RequestQueue getQueue() {
    if (queue == null) {
        queue = Volley.newRequestQueue(getApplicationContext());
        return queue;
    }
    return queue;
}
}

अब, आप getInstance () विधि का उपयोग करके वॉली उदाहरण का उपयोग कर सकते हैं और InitApplication.getInstance().addToQueue(request); का उपयोग करके कतार में एक नया अनुरोध जोड़ सकते हैं InitApplication.getInstance().addToQueue(request);

सर्वर से JsonObject का अनुरोध करने के लिए एक सरल उदाहरण है

JsonObjectRequest myRequest = new JsonObjectRequest(Method.GET,
        url, null,
        new Response.Listener<JSONObject>() {

            @Override
            public void onResponse(JSONObject response) {
                Log.d(TAG, response.toString());
            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                Log.d(TAG, "Error: " + error.getMessage());
            }
});

myRequest.setRetryPolicy(new DefaultRetryPolicy(
        MY_SOCKET_TIMEOUT_MS, 
        DefaultRetryPolicy.DEFAULT_MAX_RETRIES, 
        DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));

वॉली टाइमआउट को संभालने के लिए आपको एक RetryPolicy का उपयोग करना RetryPolicy । नेटवर्क की विफलता या कुछ अन्य मामलों के कारण अनुरोध पूरा नहीं होने की स्थिति में एक रिट्री पॉलिसी का उपयोग किया जाता है।

वॉली आपके अनुरोधों के लिए अपने RetryPolicy को लागू करने का एक आसान तरीका प्रदान करता है। डिफ़ॉल्ट रूप से, वॉली सभी अनुरोधों के लिए 5 सेकंड के लिए सभी सॉकेट और कनेक्शन टाइमआउट सेट करता है। RetryPolicy एक इंटरफ़ेस है जहाँ आपको अपने तर्क को लागू करने की आवश्यकता होती है कि कैसे आप एक विशेष अनुरोध को पुनः प्राप्त करना चाहते हैं जब कोई टाइमआउट होता है।

निर्माणकर्ता निम्नलिखित तीन पैरामीटर लेता है:

• initialTimeoutMs - प्रत्येक पुन: प्रयास के लिए मिलीसेकंड में सॉकेट टाइमआउट निर्दिष्ट करता है।
• maxNumRetries - maxNumRetries बार maxNumRetries की कोशिश की जाती है।
• backoffMultiplier - एक गुणक जिसका उपयोग backoffMultiplier प्रयास के लिए गर्तिका में घातीय समय निर्धारित करने के लिए किया जाता है।

वॉली में json अनुरोध के साथ सर्वर से बूलियन चर प्रतिक्रिया

आप एक के नीचे कस्टम क्लास कर सकते हैं

private final String PROTOCOL_CONTENT_TYPE = String.format("application/json; charset=%s", PROTOCOL_CHARSET);

    public BooleanRequest(int method, String url, String requestBody, Response.Listener<Boolean> listener, Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
        this.mRequestBody = requestBody;
    }

    @Override
    protected Response<Boolean> parseNetworkResponse(NetworkResponse response) {
        Boolean parsed;
        try {
            parsed = Boolean.valueOf(new String(response.data, HttpHeaderParser.parseCharset(response.headers)));
        } catch (UnsupportedEncodingException e) {
            parsed = Boolean.valueOf(new String(response.data));
        }
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }

    @Override
    protected VolleyError parseNetworkError(VolleyError volleyError) {
        return super.parseNetworkError(volleyError);
    }

    @Override
    protected void deliverResponse(Boolean response) {
        mListener.onResponse(response);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }

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

    @Override
    public byte[] getBody() throws AuthFailureError {
        try {
            return mRequestBody == null ? null : mRequestBody.getBytes(PROTOCOL_CHARSET);
        } catch (UnsupportedEncodingException uee) {
            VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s",
                    mRequestBody, PROTOCOL_CHARSET);
            return null;
        }
    }
}

इसे अपनी गतिविधि के साथ प्रयोग करें

try {
        JSONObject jsonBody;
        jsonBody = new JSONObject();
        jsonBody.put("Title", "Android Demo");
        jsonBody.put("Author", "BNK");
        jsonBody.put("Date", "2015/08/28");
        String requestBody = jsonBody.toString();
        BooleanRequest booleanRequest = new BooleanRequest(0, url, requestBody, new Response.Listener<Boolean>() {
            @Override
            public void onResponse(Boolean response) {
                Toast.makeText(mContext, String.valueOf(response), Toast.LENGTH_SHORT).show();
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Toast.makeText(mContext, error.toString(), Toast.LENGTH_SHORT).show();
            }
        });
        // Add the request to the RequestQueue.
        queue.add(booleanRequest);
    } catch (JSONException e) {
        e.printStackTrace();
    }

अनुरोध निकाय के रूप में JSONArray का उपयोग करें

वॉली में एकीकृत डिफ़ॉल्ट अनुरोध POST अनुरोध में अनुरोध निकाय के रूप में JSONArray को पारित करने की अनुमति नहीं देते हैं। इसके बजाय, आप केवल एक JSON ऑब्जेक्ट को एक पैरामीटर के रूप में पास कर सकते हैं।

हालांकि, बजाय एक में उत्तीर्ण होने की JSON अनुरोध निर्माता को पैरामीटर के रूप वस्तु, आप ओवरराइड करने के लिए की जरूरत है getBody() की विधि Request.class । आपको तीसरे पैरामीटर के साथ null होना चाहिए:

JSONArray requestBody = new JSONArray();

new JsonObjectRequest(Request.Method.POST, REQUEST_URL, null, RESP_LISTENER, ERR_LISTENER) {
    @Override
    public byte[] getBody() {
        try {
            return requestBody.toString().getBytes(PROTOCOL_CHARSET);
        } catch (UnsupportedEncodingException uee) {
            // error handling
            return null;
        }
    }
};

मापदंडों की व्याख्या:

• REQUEST_URL - आपके अनुरोध को भेजने के लिए पूरा URL।
• RESP_LISTENER - एक Response.Listener<?> RESP_LISTENER Response.Listener<?> ऑब्जेक्ट, जिसके onResponse(T data) विधि को सफल समापन कहा जाता है।
• ERR_LISTENER - एक Response.ErrorListener ERR_LISTENER ऑब्जेक्ट, जिसका onErrorResponse(VolleyError e) विधि असफल अनुरोध पर कहा जाता है।