public static Map<String, String> postData(EndPointInfo endPointInfo, Map<String, String> headers)
      throws IDPTokenManagerException {

    HTTP_METHODS httpMethod = endPointInfo.getHttpMethod();
    String url = endPointInfo.getEndPoint();

    String params = null;

    if (endPointInfo != null && endPointInfo.getRequestParams() != null) {
      params = endPointInfo.getRequestParams();
    }

    Map<String, String> responseParams = new HashMap<String, String>();

    switch (httpMethod) {
      case GET:
        responseParams = sendGetRequest(url, headers);
        break;
      case POST:
        responseParams = sendPostRequest(url, params, headers);
        break;
      case DELETE:
        responseParams = sendDeleteRequest(url, headers);
        break;
      case PUT:
        responseParams = sendPutRequest(url, params, headers);
        break;
    }

    return responseParams;
  }
  /**
   * This method is used to send requests to backend. The reason to use this method because the
   * function which is already available for sending requests is secured with token. Therefor this
   * can be used to send requests without tokens.
   */
  private void sendRequest(
      final EndPointInfo endPointInfo,
      final APIResultCallBack apiResultCallback,
      final int requestCode) {
    RequestQueue queue = null;
    int requestMethod = 0;
    org.wso2.emm.agent.proxy.utils.Constants.HTTP_METHODS httpMethod = endPointInfo.getHttpMethod();
    switch (httpMethod) {
      case POST:
        requestMethod = Request.Method.POST;
        break;
      case DELETE:
        requestMethod = Request.Method.DELETE;
        break;
    }

    try {
      queue = ServerUtilities.getCertifiedHttpClient();
    } catch (IDPTokenManagerException e) {
      Log.e(TAG, "Failed to retrieve HTTP client", e);
    }

    JsonObjectRequest request = null;
    try {
      request =
          new JsonObjectRequest(
              requestMethod,
              endPointInfo.getEndPoint(),
              (endPointInfo.getRequestParams() != null)
                  ? new JSONObject(endPointInfo.getRequestParams())
                  : 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.toString());
                }
              }) {
            @Override
            protected Response<JSONObject> parseNetworkResponse(NetworkResponse response) {
              String result = new String(response.data);
              if (org.wso2.emm.agent.proxy.utils.Constants.DEBUG_ENABLED) {
                if (result != null && !result.isEmpty()) {
                  Log.d(TAG, "Result :" + result);
                }
              }
              Map<String, String> responseParams = new HashMap<>();
              responseParams.put(
                  org.wso2.emm.agent.proxy.utils.Constants.SERVER_RESPONSE_BODY, result);
              responseParams.put(
                  org.wso2.emm.agent.proxy.utils.Constants.SERVER_RESPONSE_STATUS,
                  String.valueOf(response.statusCode));
              if (apiResultCallback != null) {
                apiResultCallback.onReceiveAPIResult(responseParams, requestCode);
              }
              return super.parseNetworkResponse(response);
            }

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
              Map<String, String> headers = new HashMap<>();
              headers.put("Content-Type", "application/json");
              headers.put("Accept", "application/json");
              headers.put("User-Agent", Constants.USER_AGENT);
              if (endPointInfo.getHeader() != null && !endPointInfo.getHeader().trim().isEmpty()) {
                headers.put("Authorization", endPointInfo.getHeader().trim());
              }
              return headers;
            }
          };
    } catch (JSONException e) {
      Log.e(TAG, "Failed to parse request JSON", e);
    }

    queue.add(request);
  }