android networking library

Android Networking Library | Top 5 Curated List

Android networking library can be used in an android application to send http request and fetch data online from server.

In this blog we have covered a curated list of top 5 such android networking libraries that can help you in performing networking requests.

OkHTTP Networking Library

OkHTTP is a HTTP Client networking library. It helps in exchanging data and other forms of media with online servers by sending requests.

What makes OkHttp an efficient library is that it helps in loading data faster and saves bandwidth. The library has more than 34,000 stars and 7400 forks at GitHub. Making it a choice of many great developer.

Features

Some features of OkHttp library are as follows:

  1. All requests to same hosts are made on the same socket, it helps in economic use of device resources and makes it more efficient.
  2. It pools the connection to reduce network latency.
  3. Shrinking download size is possible using Transparent GZIP so the content length is reduced.
  4. OkHttp supports response caching to reduce network request.
  5. If a particular IP Address fails in network request, OkHttps uses other IP Address to send network request.
  6. OkHttp supports both synchronous blocking calls and async calls with callbacks.

Implementing OkHttp in Project

To implement OkHttp in your Android Studio project, add the following lines to your build.gradle file:

implementation("com.squareup.okhttp3:okhttp:4.1.0")

Sending GET Request

Here is how you send a GET request in OkHttp:

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

Sending a POST Request

public static final MediaType JSON
    = MediaType.get("application/json; charset=utf-8");

OkHttpClient client = new OkHttpClient();

String post(String url, String json) throws IOException {
  RequestBody body = RequestBody.create(JSON, json);
  Request request = new Request.Builder()
      .url(url)
      .post(body)
      .build();
  try (Response response = client.newCall(request).execute()) {
    return response.body().string();
  }
}

Link to Github

Fast Android Networking Library

Fast Android Networking library is an advance version of OkHTTP Library.

Its build on the top of OkHttp. This makes it fast and efficient with added new features.

Features

  1. Fast Android Networking library is fast and easy to implement
  2. It provide all features of OkHttp Library
  3. It uses Okio, to handle garbage collection overhead while allocating memory. Okio does some clever things to save CPU and memory.
  4. Fast Android Networking Library supports all types of HTTP/HTTPS request like GET, POST, DELETE, HEAD, PUT, PATCH
  5. Fast Android Library supports downloading any type of file.
  6. Fast Android Library supports uploading any type of file (supports multipart upload).
  7. Fast Android Library supports cancelling a request.
  8. Fast Android Library supports setting priority to any request (LOW, MEDIUM, HIGH, IMMEDIATE)
  9. Fast Android Library supports RxJava

Implementing Fast Android Networking Library

implementation 'com.amitshekhar.android:android-networking:1.0.2'

Send GET Request

Initialize Library in onCreate()

AndroidNetworking.initialize(getApplicationContext());

Sending GET Request

AndroidNetworking.get("https://fierce-cove-29863.herokuapp.com/getAllUsers/{pageNumber}")
                 .addPathParameter("pageNumber", "0")
                 .addQueryParameter("limit", "3")
                 .addHeaders("token", "1234")
                 .setTag("test")
                 .setPriority(Priority.LOW)
                 .build()
                 .getAsJSONArray(new JSONArrayRequestListener() {
                    @Override
                    public void onResponse(JSONArray response) {
                      // do anything with response | RETURN TO ONPOSTEXTEUTE()
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });               

Making POST Request

Initialize library in onCreate()

AndroidNetworking.initialize(getApplicationContext());

Send POST Request

AndroidNetworking.post("https://fierce-cove-29863.herokuapp.com/createAnUser")
                 .addBodyParameter("firstname", "Amit")
                 .addBodyParameter("lastname", "Shekhar")
                 .setTag("test")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // do anything with response
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

Downloading File Request

AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });   

Uploading File Request

AndroidNetworking.upload(url)
                 .addMultipartFile("image",file)    
                 .addMultipartParameter("key","value")
                 .setTag("uploadTest")
                 .setPriority(Priority.HIGH)
                 .build()
                 .setUploadProgressListener(new UploadProgressListener() {
                    @Override
                    public void onProgress(long bytesUploaded, long totalBytes) {
                      // do anything with progress 
                    }
                 })
                 .getAsJSONObject(new JSONObjectRequestListener() {
                    @Override
                    public void onResponse(JSONObject response) {
                      // do anything with response                
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error 
                    }
                 }); 

Other Features

Enabling GZIP From Client to server

Enabling GZIP for Request (Not needed if your server doesn’t support GZIP Compression), anyway responses from server are automatically unGzipped if required. So enable it only if you need your request to be Gzipped before sending to server(Make sure your server support GZIP Compression).

OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
                .addInterceptor(new GzipRequestInterceptor())
                .build();
AndroidNetworking.initialize(getApplicationContext(),okHttpClient);   

Getting Analytics of a request

AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .build()
                 .setAnalyticsListener(new AnalyticsListener() {
                      @Override
                      public void onReceived(long timeTakenInMillis, long bytesSent, long bytesReceived, boolean isFromCache) {
                          Log.d(TAG, " timeTakenInMillis : " + timeTakenInMillis);
                          Log.d(TAG, " bytesSent : " + bytesSent);
                          Log.d(TAG, " bytesReceived : " + bytesReceived);
                          Log.d(TAG, " isFromCache : " + isFromCache);
                      }
                  })
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });  

Connection listener to get quality of Network

// Adding Listener
AndroidNetworking.setConnectionQualityChangeListener(new ConnectionQualityChangeListener() {
            @Override
            public void onChange(ConnectionQuality currentConnectionQuality, int currentBandwidth) {
              // do something on change in connectionQuality
            }
        });
        
// Removing Listener   
AndroidNetworking.removeConnectionQualityChangeListener();

// Getting current ConnectionQuality
ConnectionQuality connectionQuality = AndroidNetworking.getCurrentConnectionQuality();
if(connectionQuality == ConnectionQuality.EXCELLENT) {
  // do something
} else if (connectionQuality == ConnectionQuality.POOR) {
  // do something
} else if (connectionQuality == ConnectionQuality.UNKNOWN) {
  // do something
}
// Getting current bandwidth
int currentBandwidth = AndroidNetworking.getCurrentBandwidth(); // Note : if (currentBandwidth == 0) : means UNKNOWN

Getting Bitmap from url with some specified parameters

Great for Unsplash API, you can use the Android Networking Library to get Bitmap of a file from a specified URL and specify certain parameters like height, width of an image.

AndroidNetworking.get(imageUrl)
                 .setTag("imageRequestTag")
                 .setPriority(Priority.MEDIUM)
                 .setBitmapMaxHeight(100)
                 .setBitmapMaxWidth(100)
                 .setBitmapConfig(Bitmap.Config.ARGB_8888)
                 .build()
                 .getAsBitmap(new BitmapRequestListener() {
                    @Override
                    public void onResponse(Bitmap bitmap) {
                    // do anything with bitmap
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error
                    }
                });

Loading image from network into ImageView

To load an image from network into the imageview widget, use the ANImageView widget in the activity XML file and the following Java code.

You can also see here how to download image from URL and requesting permissions

 <com.androidnetworking.widget.ANImageView
          android:id="@+id/imageView"
          android:layout_width="100dp"
          android:layout_height="100dp"
          android:layout_gravity="center" />
          
      imageView.setDefaultImageResId(R.drawable.default);
      imageView.setErrorImageResId(R.drawable.error);
      imageView.setImageUrl(imageUrl);          

Cancelling a request

One can cancel a request by using following line of code:

AndroidNetworking.cancel("tag"); // All the requests with the given tag will be cancelled.
AndroidNetworking.forceCancel("tag");  // All the requests with the given tag will be cancelled , even if any percent threshold is
                                       // set , it will be cancelled forcefully. 
AndroidNetworking.cancelAll(); // All the requests will be cancelled.  
AndroidNetworking.forceCancelAll(); // All the requests will be cancelled , even if any percent threshold is
                               // set , it will be cancelled forcefully.                  

Not Cancelling a request if certain threshold is achieved

You can set a certain percentage of threshold so if its achieved then the request doesn’t get cancelled.

AndroidNetworking.download(url,dirPath,fileName)
                 .setTag("downloadTest")
                 .setPriority(Priority.MEDIUM)
                 .setPercentageThresholdForCancelling(50) // even if at the time of cancelling it will not cancel if 50% 
                 .build()                                 // downloading is done.But can be cancalled with forceCancel.
                 .setDownloadProgressListener(new DownloadProgressListener() {
                    @Override
                    public void onProgress(long bytesDownloaded, long totalBytes) {
                      // do anything with progress  
                    }
                 })
                 .startDownload(new DownloadListener() {
                    @Override
                    public void onDownloadComplete() {
                      // do anything after completion
                    }
                    @Override
                    public void onError(ANError error) {
                      // handle error    
                    }
                });   

Link to Github

Volley Networking Library

Volley is an HTTP Networking Android Library that makes it faster and easier for developers to send request to servers from app.

Features

  1. Volley allows automatic scheduling of network requests
  2. It can maintain concurrent network requests
  3. It has support for request priotitization
  4. Allows to cancel a single or a block of request(s).
  5. Can be customized with extra features like backoff and retry.
  6. Supports Memory response caching to limit request sent to server.
  7. Supported ordering so data can be easily populated in the UI as the data is fetched asynchronously from the network.
  8. Has debugging and tracing tools.
  9. Volley frees you from writing boilerplate code and allows you to concentrate on the logic that is specific to your app.

However, Volley is not suitable for large download or streaming operations, since Volley holds all responses in memory during parsing. For large download operations, consider other libraries discussed in this blog.

android networking request
Lifecycle of a Volley Request

Implementing Volley

Add volley implementation to your build.gradle android project dependencies

dependencies {
    implementation 'com.android.volley:volley:1.1.1'
}

Sending GET Request

Using Volley Networking library you can send a GET request to server by creating a RequetQueue and passing it the Request objects.

The RequestQueue manages the worker thread for running network operations, reading and writing to cache and parsing the responses.

Requests do the parsing of raw responses and Volley takes care of dispatching the parsed response back to the main thread for delivery.

Read more about GET Requests from here.

// 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.
        textView.setText("Response is: "+ response.substring(0,500));
    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        textView.setText("That didn't work!");
    }
});

// Add the request to the RequestQueue.
queue.add(stringRequest);

Cancel a Request

To cancel a request, call cancel() on your Request object.

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

Learn more about RequestQueue from here.

Sending POST Request

This is how one can send a POST Request from Volley Networking library

try {
    RequestQueue requestQueue = Volley.newRequestQueue(this);
    String URL = "http://...";
    JSONObject jsonBody = new JSONObject();
    jsonBody.put("Title", "Android Volley Demo");
    jsonBody.put("Author", "BNK");
    final String requestBody = jsonBody.toString();

    StringRequest stringRequest = new StringRequest(Request.Method.POST, URL, new Response.Listener<String>() {
        @Override
        public void onResponse(String response) {
            Log.i("VOLLEY", response);
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Log.e("VOLLEY", error.toString());
        }
    }) {
        @Override
        public String getBodyContentType() {
            return "application/json; charset=utf-8";
        }

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

        @Override
        protected Response<String> parseNetworkResponse(NetworkResponse response) {
            String responseString = "";
            if (response != null) {
                responseString = String.valueOf(response.statusCode);
                // can get more details such as response.headers
            }
            return Response.success(responseString, HttpHeaderParser.parseCacheHeaders(response));
        }
    };

    requestQueue.add(stringRequest);
} catch (JSONException e) {
    e.printStackTrace();
}

Link to Github

Retrofit Networking Library

Retrofit is a type-safe HTTP Client for Android and Java.

Type-Safe means that the compiler will validate types while compiling, and throw an error if you try to assign the wrong type to a variable.

Implementing Retrofit

Add Retrofit, GSON and GSON Converter library to your project implementation

    // retrofit, gson
    implementation 'com.google.code.gson:gson:2.8.5'
    implementation 'com.squareup.retrofit2:retrofit:2.4.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.4.0'

Sending GET Request

For sending a GET request, Retrofit gives you the option of the synchronous and asynchronous HTTP request.

Depending on how you declare your interface method, it will either be synchronous or asynchronous HTTP Request.

public interface MyInterface {
    // Synchronous declaration
    @GET("/my_api/shop_list") 
    Response getMyThing1(@Query("mid") String param1);

    // Asynchronous declaration
    @GET("/my_api/shop_list")
    void getMyThing2(@Query("mid") String param1, Callback<Response> callback);
}

To get access to the data received from the server is to map the JSON class to Java object and let Retrofit do the conversion.

Making a GET Request

   Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://api.apiurl.com/base/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        service = retrofit.create(APIService.class);

Read more about Retrofit here.

Link to Github

Cornet Networking Library

Cronet android networking library is a framework that using chromium net to send network request for android.

For easy implementation we are using library forked by Lizhangqu.

Implementation

Add following lines of code to your build.gradle file

implementation 'io.github.lizhangqu:cronet-native:73.0.3653.0.5'

Sending GET Request

Sending GET request with other callbacks

UrlRequest.Builder builder = new UrlRequest.Builder(mEditTextUrl.getText().toString(), new UrlRequest.Callback() {
     private ByteArrayOutputStream mBytesReceived = new ByteArrayOutputStream();
     private WritableByteChannel mReceiveChannel = Channels.newChannel(mBytesReceived);

     @Override
     public void onRedirectReceived(UrlRequest urlRequest, UrlResponseInfo urlResponseInfo, String s) throws Exception {
         Log.i("TAG", "onRedirectReceived");
         urlRequest.followRedirect();
     }

     @Override
     public void onResponseStarted(UrlRequest urlRequest, UrlResponseInfo urlResponseInfo) throws Exception {
         Log.i("TAG", "onResponseStarted");
         urlRequest.read(ByteBuffer.allocateDirect(32 * 1024));
     }

     @Override
     public void onReadCompleted(UrlRequest urlRequest, UrlResponseInfo urlResponseInfo, ByteBuffer byteBuffer) throws Exception {
         Log.i("TAG", "onReadCompleted");
         byteBuffer.flip();

         try {
             mReceiveChannel.write(byteBuffer);
         } catch (IOException e) {
             e.printStackTrace();
         }
         byteBuffer.clear();
         urlRequest.read(byteBuffer);
     }

     @Override
     public void onSucceeded(UrlRequest urlRequest, UrlResponseInfo urlResponseInfo) {
         Log.i("TAG", "onSucceeded");
         Log.i("TAG", String.format("Request Completed, status code is %d, total received bytes is %d",
                 urlResponseInfo.getHttpStatusCode(), urlResponseInfo.getReceivedBytesCount()));

         final String receivedData = mBytesReceived.toString();
         final String url = urlResponseInfo.getUrl();
         final String text = "Completed " + url + " (" + urlResponseInfo.getHttpStatusCode() + ")";

         Log.i("TAG", "text:" + text);
         Log.i("TAG", "receivedData:" + receivedData);
         Handler handler = new Handler(Looper.getMainLooper());
         handler.post(new Runnable() {
             @Override
             public void run() {
                 Toast.makeText(getApplicationContext(), "onSucceeded", Toast.LENGTH_SHORT).show();
             }
         });
     }

     @Override
     public void onFailed(UrlRequest urlRequest, UrlResponseInfo urlResponseInfo, UrlRequestException e) {
         Log.i("TAG", "onFailed");
         Log.i("TAG", "error is: %s" + e.getMessage());

         Handler handler = new Handler(Looper.getMainLooper());
         handler.post(new Runnable() {
             @Override
             public void run() {
                 Toast.makeText(getApplicationContext(), "onFailed", Toast.LENGTH_SHORT).show();
             }
         });
     }
 }, executor, cronetEngine);
 builder.build().start();

Sending POST Request

public void startWithURL(String url, UrlRequest.Callback callback, Executor executor, String postData) {
    UrlRequest.Builder builder = new UrlRequest.Builder(url, callback, executor, mCronetEngine);
    applyPostDataToUrlRequestBuilder(builder, executor, postData);
    builder.build().start();
}

private void applyPostDataToUrlRequestBuilder(
        UrlRequest.Builder builder, Executor executor, String postData) {
    if (postData != null && postData.length() > 0) {
        builder.setHttpMethod("POST");
        builder.addHeader("Content-Type", "application/x-www-form-urlencoded");
        builder.setUploadDataProvider(
                UploadDataProviders.create(postData.getBytes()), executor);
    }
}

And then reuse the callback in Send GET Request

Link to Github

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.