Передача данных в android методом post. HttpURLConnection: Подключаемся к URL

Volley always delivers parsed responses on the main thread. Running on the main thread is convenient for populating UI controls with received data, as you can freely modify UI controls directly from your response handler, but it"s especially critical to many of the important semantics provided by the library, particularly related to canceling requests.

See for a description of how to set up a RequestQueue yourself, instead of using the Volley.newRequestQueue convenience method.

Send a request

To send a request, you simply construct one and add it to the RequestQueue with add() , as shown above. Once you add the request it moves through the pipeline, gets serviced, and has its raw response parsed and delivered.

When you call add() , Volley runs one cache processing thread and a pool of network dispatch threads. When you add a request to the queue, it is picked up by the cache thread and triaged: if the request can be serviced from cache, the cached response is parsed on the cache thread and the parsed response is delivered on the main thread. If the request cannot be serviced from cache, it is placed on the network queue. The first available network thread takes the request from the queue, performs the HTTP transaction, parses the response on the worker thread, writes the response to cache, and posts the parsed response back to the main thread for delivery.

Note that expensive operations like blocking I/O and parsing/decoding are done on worker threads. You can add a request from any thread, but responses are always delivered on the main thread.

Figure 1 illustrates the life of a request:

Figure 1. Life of a request.

Cancel a request

To cancel a request, call cancel() on your Request object. Once cancelled, Volley guarantees that your response handler will never be called. What this means in practice is that you can cancel all of your pending requests in your activity"s method and you don"t have to litter your response handlers with checks for getActivity() == null , whether onSaveInstanceState() has been called already, or other defensive boilerplate.

To take advantage of this behavior, you would typically have to track all in-flight requests in order to be able to cancel them at the appropriate time. There is an easier way: you can associate a tag object with each request. You can then use this tag to provide a scope of requests to cancel. For example, you can tag all of your requests with the they are being made on behalf of, and call requestQueue.cancelAll(this) from . Similarly, you could tag all thumbnail image requests in a tab with their respective tabs and cancel on swipe to make sure that the new tab isn"t being held up by requests from another one.

Here is an example that uses a string value for the tag:

1. Define your tag and add it to your requests.

   Kotlin

   val TAG = "MyTag" val stringRequest: StringRequest // Assume this exists. val requestQueue: RequestQueue? // Assume this exists. // Set the tag on the request. stringRequest.tag = TAG // Add the request to the RequestQueue. requestQueue?.add(stringRequest)

   Java

   public static final String TAG = "MyTag"; StringRequest stringRequest; // Assume this exists. RequestQueue requestQueue; // Assume this exists. // Set the tag on the request. stringRequest.setTag(TAG); // Add the request to the RequestQueue. requestQueue.add(stringRequest);
2. In your activity"s method, cancel all requests that have this tag.

   Kotlin

   protected fun onStop() { super.onStop() requestQueue?.cancelAll(TAG) }

   Java

   @Override protected void onStop () { super.onStop(); if (requestQueue != null) { requestQueue.cancelAll(TAG); } }

   Take care when canceling requests. If you are depending on your response handler to advance a state or kick off another process, you need to account for this. Again, the response handler will not be called.

In Android HTTP POST & GET tutorial , I have explained how to send HTTP POST and GET requests programmatically in Android.

We can use org.apache.http.client.HttpClient class to make HTTP requests.

Send HTTP POST request

Follow the steps to send HTTP POST requests.

HttpClient httpClient = new DefaultHttpClient();

2. Create an object of HttpPost

HttpPost httpPost = new HttpPost("http://www.example.com");

3. Add POST parameters

List (2); nameValuePair.add(new BasicNameValuePair("username", "test_user")); nameValuePair.add(new BasicNameValuePair("password", "123456789"));

4. Encode POST data

We need to encode our data into valid URL format before making HTTP request.

//Encoding POST data try { httpPost.setEntity(new UrlEncodedFormEntity(nameValuePair)); } catch (UnsupportedEncodingException e) { e.printStackTrace(); }

5. Finally making an HTTP POST request

Try { HttpResponse response = httpClient.execute(httpPost); // write response to log Log.d("Http Post Response:", response.toString()); } catch (ClientProtocolException e) { // Log exception e.printStackTrace(); } catch (IOException e) { // Log exception e.printStackTrace(); }

Make sure you add Internet permission to your app before making such requests else you might see some errors.

You can add Internet permissions by adding this line to your manifest file above application tag.

Android HTTP POST Example