Volley

Integration in Android Studio:

dependencies {
			...
			implementation ("com.android.volley:volley:1.2.1")
			...
}

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

Making a Simple GET Request in Kotlin:

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.android.volley.Request
import com.android.volley.Response
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Instantiate the RequestQueue
        val requestQueue = Volley.newRequestQueue(this)

        // Define the URL
        val url = "https://api.example.com/data"

        // Create a request
        val stringRequest = StringRequest(Request.Method.GET, url,
            Response.Listener<String> { response ->
                // Handle the response
                // Process the JSON data or perform operations on the response
                Log.d("VolleyResponse", response)
            },
            Response.ErrorListener { error ->
                // Handle errors
                // Handle errors such as network issues or server errors
                Log.e("VolleyError", error.toString())
            })

        // Add the request to the RequestQueue
        requestQueue.add(stringRequest)
    }
}

• Volley.newRequestQueue(this) creates a new RequestQueue instance.

• StringRequest is used for making a GET request to the specified URL.

• Inside the StringRequest constructor, you define the success and error listeners to handle the response or errors respectively.

• requestQueue.add(stringRequest) adds the request to the queue, allowing Volley to handle it asynchronously.

JSON Array Request:

// Instantiate the RequestQueue
val requestQueue = Volley.newRequestQueue(this)

// Define the URL of API
val url = "https://api.example.com/dataArray"

// Create a request
val stringRequest = StringRequest(Request.Method.GET, url, 
{ 
    // Handle the JSON Array response
		val jArr = JSONArray(it)

    // Parse the JSON array or perform operations on the response
    for (i in 0 ..< jArr.length()) {

        val jsonObject = jArr.getJSONObject(i)
        val name = jsonObject.getString("name")
        val age = jsonObject.getInt("age")

        // Process each JSON object in the array
        Log.d("VolleyResponse", "Name: $name, Age: $age")
    }
},
Response.ErrorListener { error ->
    // Handle errors such as network issues or server errors
    Log.e("VolleyError", "${error.localizedMessage}")
})

// Add the request to the RequestQueue
requestQueue.add(jsonArrayRequest)

Explanation:

• JSONArray(it) is used to fetch a JSON array from the API.

• the for loop iterates through each object in the JSON array (jArr.length() provides the array length).

• jArr.getJSONObject(i) retrieves each JSON object from the array, and you can then extract specific fields using methods like getString or getInt.

JSON Object Request:

// ... (Previous code remains the same)

// Define the URL of API
val urlObject = "https://api.example.com/dataObject"

// Create a request
val stringRequest = StringRequest(Request.Method.GET, urlObject, 
  Response.Listener<JSONObject> { response ->
      // Handle the JSON Object response
      // Parse the JSON object or perform operations on the response
      val name = response.getString("name")
      val age = response.getInt("age")
      // Use the retrieved data as needed
      Log.d("VolleyResponse", "Name: $name, Age: $age")
  },
  Response.ErrorListener { error ->
      // Handle errors such as network issues or server errors
      Log.e("VolleyError", "${error.localizedMessage}")
  })

// ... (Rest of the code remains the same)

Making a Simple POST Request in Kotlin:

// new Volley request 
val queue = Volley.newRequestQueue(this@MainActivity)
// url of Api 
val url = "https://kotlinweb.000webhostapp.com/Ecommerce/register.php"

// object of StringRequest with POST method  
val stringRequest = object : StringRequest(Request.Method.POST, url
     {
				// response 
        Log.e("====", "onResponse: $it")
      },
      {
				// error 
        Log.e("====", "onErrorResponse: ${it!!.localizedMessage}")
      } )
		  {
				// overridden method to provide values to api 
				// it will provide values as in map(key,value)
        override fun getParams(): MutableMap<String, String>? {
            var hashmap = hashMapOf<String, String>()

              hashmap["name"] = name.text.toString()
              hashmap["email"] = email.text.toString()
              hashmap["number"] = number.text.toString()
              hashmap["password"] = password.text.toString()
              return hashmap
	           }
      }

// add stringRequest to queue(volley request)
queue.add(stringRequest)

• Volley.newRequestQueue(this) creates a new RequestQueue instance.

• object : StringRequest( ... ) { ... } is used for making a POST request to the specified URL.
• it must be created as object to override predefined methods
• and this override method are written between method block { .. }

• override fun getParams(): MutableMap<String, String>? { ... }
• this override function must be added to provide values to API/URL with POST method

• queue.add(stringRequest) adds the request to the queue, allowing Volley to handle it synchronously.

Passing Values as JSON body instead of Params

override fun getBody(): ByteArray {
        val jb = JSONObject()

        jb.put("mobile","7276465975")
        jb.put("password","123")

        return jb.toString().toByteArray(Charset.defaultCharset())
}

• override fun getParams(): MutableMap<String, String>? { ... } gives sometimes gave 401 Unauthorized Error so it might be problem of mutable map list

• If Api want data in JSONObject we need to Override getBody(): ByteArray{ .. } function inside method calling.

• In this we create JSONObject convert it to String and than convert it to ByteArray to return.