tharak-android 0.0.1

package/src/main/java/org/thiragatisoft/core/RestClient.java

@@ -0,0 +1,298 @@
+package org.thiragatisoft.core;
+
+import android.app.Activity;
+import android.net.Uri;
+
+import com.android.volley.AuthFailureError;
+import com.android.volley.NetworkResponse;
+import com.android.volley.Request;
+import com.android.volley.RequestQueue;
+import com.android.volley.Response;
+import com.android.volley.ServerError;
+import com.android.volley.VolleyError;
+import com.android.volley.VolleyLog;
+import com.android.volley.toolbox.HttpHeaderParser;
+import com.android.volley.toolbox.JsonObjectRequest;
+import com.android.volley.toolbox.StringRequest;
+import com.android.volley.toolbox.Volley;
+import com.getcapacitor.CapConfig;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.NativePlugin;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.PluginResult;
+
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+import java.util.Map;
+
+@NativePlugin
+public class RestClient extends Plugin {
+
+  @PluginMethod
+  public void invoke(PluginCall call) {
+    JSObject request = call.getObject("request");
+    String method = request.getString("method");
+    switch (method){
+      case "POST":
+        performBodyCall(call, Request.Method.POST);
+        break;
+      case "PUT":
+        performBodyCall(call, Request.Method.PUT);
+        break;
+      case "PATCH":
+        performBodyCall(call, Request.Method.PATCH);
+        break;
+      case "GET":
+        performUrlCall(call, Request.Method.GET);
+        break;
+      case "DELETE":
+        performUrlCall(call, Request.Method.DELETE);
+        break;
+      default:
+        performUrlCall(call, Request.Method.GET);
+    }
+  }
+  public void performUrlCall(PluginCall call, int method) {
+    JSObject request = call.getObject("request");
+    String requestURL = request.getString("url");
+    String responseType = request.getString("responseType");
+    JSONObject options = call.getObject("headers");
+    RequestQueue queue = Volley.newRequestQueue(bridge.getContext());
+    JsonObjectRequest stringRequest = new JsonObjectRequest(method, requestURL, null, new Response.Listener<JSONObject>() {
+      @Override
+      public void onResponse(JSONObject response) {
+        // Display the first 500 characters of the response string.
+        try {
+          call.success(new JSObject(response.toString()));
+        }catch (Exception ex){
+          ex.printStackTrace();
+        }
+      }
+    }, new Response.ErrorListener() {
+      @Override
+      public void onErrorResponse(VolleyError error) {
+        RestClient.addError(call, error);
+      }
+    }) {
+      //
+      @Override
+      public Map<String, String> getHeaders() {
+        return RestClient.getHeaders(options);
+      }
+    };
+    // Add the request to the RequestQueue.
+    queue.add(stringRequest);
+  }
+  public void performBodyCall(PluginCall call, int method) {
+    JSObject request = call.getObject("request");
+    String requestURL = request.getString("url");
+    String responseType = request.getString("responseType");
+    RequestQueue queue = Volley.newRequestQueue(bridge.getContext());
+    Request volyRequest = findRequest(call, method, requestURL, this.getActivity());
+    // Add the request to the RequestQueue.
+    queue.add(volyRequest);
+  }
+  private static Request findRequest(PluginCall call, int method, String requestURL, Activity activity) {
+    try {
+      JSONObject request = call.getObject("request");
+      JSONObject options = call.getObject("headers");
+      String ignoreType = options.getString("Ignore-Type");
+      String contentType = options.getString("Content-Type");
+      if("Y".equalsIgnoreCase(ignoreType)){
+        contentType = "multipart/formdata";
+      }
+      if(contentType == null)
+        contentType = "application/json";
+      if(contentType.contains("application/json")){
+        JSONObject body = null;
+        if(method != Request.Method.GET && method != Request.Method.DELETE){
+          body = request.getJSONObject("body");
+        }
+        return new JsonObjectRequest(method, requestURL, body, new Response.Listener<JSONObject>() {
+          @Override
+          public void onResponse(JSONObject response) {
+            // Display the first 500 characters of the response string.
+            try {
+              call.success(new JSObject(response.toString()));
+            }catch (Exception ex){
+              ex.printStackTrace();
+            }
+          }
+        }, new Response.ErrorListener() {
+          @Override
+          public void onErrorResponse(VolleyError error) {
+            RestClient.addError(call, error);
+          }
+        }){
+          //
+          @Override
+          public Map<String, String> getHeaders() {
+            return RestClient.getHeaders(options);
+          }
+        };
+      }else if(contentType.contains("multipart/")){
+        JSONObject body = null;
+        body = request.getJSONObject("body");
+        String fileName = body.getString("fileName");
+
+        JSONObject finalBody = body;
+        return new VolleyMultipartRequest(method, requestURL, new Response.Listener<NetworkResponse>() {
+          @Override
+          public void onResponse(NetworkResponse response) {
+            String resultResponse = new String(response.data);
+            try {
+              call.success(new JSObject(resultResponse));
+            } catch (Exception e) {
+              e.printStackTrace();
+            }
+          }
+        }, new Response.ErrorListener() {
+          @Override
+          public void onErrorResponse(VolleyError error) {
+            RestClient.addError(call, error);
+          }
+        }) {
+          @Override
+          protected Map<String, String> getParams() {
+            Map<String, String> params = new HashMap<>();
+            try {
+              if (finalBody != null) {
+                for (int idx = 0; idx < finalBody.names().length(); ++idx) {
+                  String key = finalBody.names().getString(idx);
+                  if("fileBase64".equalsIgnoreCase(key))
+                    continue;
+                  params.put(key, finalBody.getString(key));
+                }
+              }
+            }catch (Exception ex){
+              ex.printStackTrace();
+            }
+           // params.put("file", new DataPart(fileName, RestClient.getFileData(fileName)));
+            return params;
+          }
+
+          @Override
+          protected Map<String, DataPart> getByteData() {
+            Map<String, DataPart> params = new HashMap<>();
+            try {
+              String fileData = finalBody.getString("fileBase64");
+              params.put("file", new DataPart(fileName, fileData.getBytes()));
+            }catch (Exception ex){
+              ex.printStackTrace();
+            }
+            // file name could found file base or direct access from real path
+            // for now just get bitmap data from ImageView
+            //params.put("file", new DataPart(fileName, RestClient.getFileData(fileName, activity)));
+            return params;
+          }
+          @Override
+          public Map<String, String> getHeaders() {
+            return RestClient.getHeaders(options);
+          }
+        };
+      }else {
+        return new StringRequest(method, requestURL, new Response.Listener<String>() {
+          @Override
+          public void onResponse(String response) {
+            // Display the first 500 characters of the response string.
+            try {
+              call.success(new JSObject(response));
+            } catch (Exception ex) {
+              ex.printStackTrace();
+            }
+          }
+        }, new Response.ErrorListener() {
+          @Override
+          public void onErrorResponse(VolleyError error) {
+            RestClient.addError(call, error);
+          }
+        }){
+          //
+          @Override
+          public Map<String, String> getHeaders() {
+            return RestClient.getHeaders(options);
+          }
+          @Override
+          public String getBodyContentType() {
+            String bodyType = "";
+            try {
+              bodyType = options.getString("content-type") + "; charset=utf-8";
+            }catch (Exception ex){
+              ex.printStackTrace();
+            }
+            return bodyType;
+          }
+          @Override
+          public byte[] getBody() throws AuthFailureError {
+            String mRequestBody = "";
+            try {
+              mRequestBody = request.getString("body");
+              return mRequestBody == null ? null : mRequestBody.getBytes("utf-8");
+            } catch (Exception uee) {
+              VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s", mRequestBody, "utf-8");
+              return null;
+            }
+          }
+        };
+      }
+    }catch (Exception ex){
+      ex.printStackTrace();
+    }
+    return null;
+  }
+  private static void addError(PluginCall call, VolleyError error) {
+    try {
+      // As of f605da3 the following should work
+      NetworkResponse response = error.networkResponse;
+      if (error instanceof ServerError && response != null) {
+        try {
+          String res = new String(response.data,
+            HttpHeaderParser.parseCharset(response.headers, "utf-8"));
+          // Now you can use any deserializer to make sense of data
+          System.out.println(res);
+          error = new VolleyError(res);
+        } catch (UnsupportedEncodingException e1) {
+          // Couldn't properly decode data to string
+          e1.printStackTrace();
+        }
+      }
+      int errorCode = 500;
+      if(response != null){
+        errorCode = response.statusCode;
+      }
+      /*PluginResult errorResult = new PluginResult();
+      errorResult.put("message", "Error");
+      errorResult.put("code", errorCode);
+      errorResult.put("status", errorCode);
+      call.successCallback(errorResult);*/
+      call.error("Error", String.valueOf(errorCode), error);
+    }catch (Exception ex){
+      ex.printStackTrace();
+    }
+  }
+
+  private static Map<String, String> getHeaders(JSONObject options) {
+    HashMap<String, String> headers = new HashMap<>();
+    String ignoreType = null;
+    try {
+      ignoreType = options.getString("Ignore-Type");
+      for (int idx = 0; idx < options.names().length(); ++idx) {
+        String key = options.names().getString(idx);
+        headers.put(key, options.getString(key));
+      }
+    }catch (Exception ex){
+      ex.printStackTrace();
+    }
+    if(!headers.containsKey("Content-Type") && !headers.containsKey("content-type") && !"Y".equalsIgnoreCase(ignoreType)){
+      headers.put("Content-Type", "application/json; charset=utf-8");
+    }
+    return headers;
+  }
+}