tharak-android 0.0.1

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

@@ -0,0 +1,218 @@
+package org.thiragatisoft.core;
+
+import com.android.volley.AuthFailureError;
+import com.android.volley.NetworkResponse;
+import com.android.volley.ParseError;
+import com.android.volley.Request;
+import com.android.volley.Response;
+import com.android.volley.VolleyError;
+import com.android.volley.toolbox.HttpHeaderParser;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.util.Map;
+
+/**
+ * Tharak
+ */
+
+public class VolleyMultipartRequest extends Request<NetworkResponse> {
+
+    private final String twoHyphens = "--";
+    private final String lineEnd = "\r\n";
+    private final String boundary = "apiclient-" + System.currentTimeMillis();
+
+    private Response.Listener<NetworkResponse> mListener;
+    private Response.ErrorListener mErrorListener;
+    private Map<String, String> mHeaders;
+
+
+    public VolleyMultipartRequest(int method, String url,
+                                  Response.Listener<NetworkResponse> listener,
+                                  Response.ErrorListener errorListener) {
+        super(method, url, errorListener);
+        this.mListener = listener;
+        this.mErrorListener = errorListener;
+    }
+
+    @Override
+    public Map<String, String> getHeaders() throws AuthFailureError {
+        return (mHeaders != null) ? mHeaders : super.getHeaders();
+    }
+
+    @Override
+    public String getBodyContentType() {
+        return "multipart/form-data;boundary=" + boundary;
+    }
+
+    @Override
+    public byte[] getBody() throws AuthFailureError {
+        ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        DataOutputStream dos = new DataOutputStream(bos);
+
+        try {
+            // populate text payload
+            Map<String, String> params = getParams();
+            if (params != null && params.size() > 0) {
+                textParse(dos, params, getParamsEncoding());
+            }
+
+            // populate data byte payload
+            Map<String, DataPart> data = getByteData();
+            if (data != null && data.size() > 0) {
+                dataParse(dos, data);
+            }
+
+            // close multipart form data after text and file data
+            dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);
+
+            return bos.toByteArray();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * Custom method handle data payload.
+     *
+     * @return Map data part label with data byte
+     * @throws AuthFailureError
+     */
+    protected Map<String, DataPart> getByteData() throws AuthFailureError {
+        return null;
+    }
+
+    @Override
+    protected Response<NetworkResponse> parseNetworkResponse(NetworkResponse response) {
+        try {
+            return Response.success(
+                    response,
+                    HttpHeaderParser.parseCacheHeaders(response));
+        } catch (Exception e) {
+            return Response.error(new ParseError(e));
+        }
+    }
+
+    @Override
+    protected void deliverResponse(NetworkResponse response) {
+        mListener.onResponse(response);
+    }
+
+    @Override
+    public void deliverError(VolleyError error) {
+        mErrorListener.onErrorResponse(error);
+    }
+
+    /**
+     * Parse string map into data output stream by key and value.
+     *
+     * @param dataOutputStream data output stream handle string parsing
+     * @param params           string inputs collection
+     * @param encoding         encode the inputs, default UTF-8
+     * @throws IOException
+     */
+    private void textParse(DataOutputStream dataOutputStream, Map<String, String> params, String encoding) throws IOException {
+        try {
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                buildTextPart(dataOutputStream, entry.getKey(), entry.getValue());
+            }
+        } catch (UnsupportedEncodingException uee) {
+            throw new RuntimeException("Encoding not supported: " + encoding, uee);
+        }
+    }
+
+    /**
+     * Parse data into data output stream.
+     *
+     * @param dataOutputStream data output stream handle file attachment
+     * @param data             loop through data
+     * @throws IOException
+     */
+    private void dataParse(DataOutputStream dataOutputStream, Map<String, DataPart> data) throws IOException {
+        for (Map.Entry<String, DataPart> entry : data.entrySet()) {
+            buildDataPart(dataOutputStream, entry.getValue(), entry.getKey());
+        }
+    }
+
+    /**
+     * Write string data into header and data output stream.
+     *
+     * @param dataOutputStream data output stream handle string parsing
+     * @param parameterName    name of input
+     * @param parameterValue   value of input
+     * @throws IOException
+     */
+    private void buildTextPart(DataOutputStream dataOutputStream, String parameterName, String parameterValue) throws IOException {
+        dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
+        dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" + parameterName + "\"" + lineEnd);
+        dataOutputStream.writeBytes(lineEnd);
+        dataOutputStream.writeBytes(parameterValue + lineEnd);
+    }
+
+    /**
+     * Write data file into header and data output stream.
+     *
+     * @param dataOutputStream data output stream handle data parsing
+     * @param dataFile         data byte as DataPart from collection
+     * @param inputName        name of data input
+     * @throws IOException
+     */
+    private void buildDataPart(DataOutputStream dataOutputStream, DataPart dataFile, String inputName) throws IOException {
+        dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
+        dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" +
+                inputName + "\"; filename=\"" + dataFile.getFileName() + "\"" + lineEnd);
+        if (dataFile.getType() != null && !dataFile.getType().trim().isEmpty()) {
+            dataOutputStream.writeBytes("Content-Type: " + dataFile.getType() + lineEnd);
+        }
+        dataOutputStream.writeBytes(lineEnd);
+
+        ByteArrayInputStream fileInputStream = new ByteArrayInputStream(dataFile.getContent());
+        int bytesAvailable = fileInputStream.available();
+
+        int maxBufferSize = 1024 * 1024;
+        int bufferSize = Math.min(bytesAvailable, maxBufferSize);
+        byte[] buffer = new byte[bufferSize];
+
+        int bytesRead = fileInputStream.read(buffer, 0, bufferSize);
+
+        while (bytesRead > 0) {
+            dataOutputStream.write(buffer, 0, bufferSize);
+            bytesAvailable = fileInputStream.available();
+            bufferSize = Math.min(bytesAvailable, maxBufferSize);
+            bytesRead = fileInputStream.read(buffer, 0, bufferSize);
+        }
+
+        dataOutputStream.writeBytes(lineEnd);
+    }
+
+    class DataPart {
+        private String fileName;
+        private byte[] content;
+        private String type;
+
+        public DataPart() {
+        }
+
+        DataPart(String name, byte[] data) {
+            fileName = name;
+            content = data;
+        }
+
+        String getFileName() {
+            return fileName;
+        }
+
+        byte[] getContent() {
+            return content;
+        }
+
+        String getType() {
+            return type;
+        }
+
+    }
+}

package/src/main/java/org/thiragatisoft/core/http/CapacitorCookieManager.java

@@ -0,0 +1,175 @@
+package org.thiragatisoft.core.http;
+
+
+import java.net.CookieManager;
+import java.net.CookiePolicy;
+import java.net.CookieStore;
+import java.net.HttpCookie;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class CapacitorCookieManager extends CookieManager {
+
+  private final android.webkit.CookieManager webkitCookieManager;
+
+  /**
+   * Create a new cookie manager for use with @capacitor-community/http with the default cookie
+   * store and policy
+   */
+  public CapacitorCookieManager() {
+    this(null, null);
+  }
+
+  /**
+   * Create a new cookie manager for use with @capacitor-community/http with specified cookie
+   * store and cookie policy.
+   * @param store a {@code CookieStore} to be used by cookiemanager. if {@code null}, cookie
+   *              manager will use a default one, which is an in-memory CookieStore implementation.
+   * @param policy a {@code CookiePolicy} instance to be used by cookie manager as policy
+   *               callback. if {@code null}, ACCEPT_ORIGINAL_SERVER will be used.
+   */
+  public CapacitorCookieManager(CookieStore store, CookiePolicy policy) {
+    super(store, policy);
+    webkitCookieManager = android.webkit.CookieManager.getInstance();
+  }
+
+  /**
+   * Gets the cookies for the given URL.
+   * @param url the URL for which the cookies are requested
+   * @return value the cookies as a string, using the format of the 'Cookie' HTTP request header
+   */
+  public String getCookieString(String url) {
+    return webkitCookieManager.getCookie(url);
+  }
+
+  /**
+   * Gets a cookie value for the given URL and key.
+   * @param url the URL for which the cookies are requested
+   * @param key the key of the cookie to search for
+   * @return the {@code HttpCookie} value of the cookie at the key,
+   *         otherwise it will return a new empty {@code HttpCookie}
+   */
+  public HttpCookie getCookie(String url, String key) {
+    HttpCookie[] cookies = getCookies(url);
+    for (HttpCookie cookie : cookies) {
+      if (cookie.getName().equals(key)) {
+        return cookie;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Gets an array of {@code HttpCookie} given a URL.
+   * @param url the URL for which the cookies are requested
+   * @return an {@code HttpCookie} array of non-expired cookies
+   */
+  public HttpCookie[] getCookies(String url) {
+    try {
+      ArrayList<HttpCookie> cookieList = new ArrayList<>();
+      String cookieString = getCookieString(url);
+      if (cookieString != null) {
+        String[] singleCookie = cookieString.split(";");
+        for (String c : singleCookie) {
+          HttpCookie parsed = HttpCookie.parse(c).get(0);
+          parsed.setValue(parsed.getValue());
+          cookieList.add(parsed);
+        }
+      }
+      HttpCookie[] cookies = new HttpCookie[cookieList.size()];
+      return cookieList.toArray(cookies);
+    } catch (Exception ex) {
+      return new HttpCookie[0];
+    }
+  }
+
+  /**
+   * Sets a cookie for the given URL. Any existing cookie with the same host, path and name will
+   *  be replaced with the new cookie. The cookie being set will be ignored if it is expired.
+   * @param url the URL for which the cookie is to be set
+   * @param value the cookie as a string, using the format of the 'Set-Cookie' HTTP response header
+   */
+  public void setCookie(String url, String value) {
+    webkitCookieManager.setCookie(url, value);
+    flush();
+  }
+
+  /**
+   * Sets a cookie for the given URL. Any existing cookie with the same host, path and name will
+   *  be replaced with the new cookie. The cookie being set will be ignored if it is expired.
+   * @param url the URL for which the cookie is to be set
+   * @param key the {@code HttpCookie} name to use for lookup
+   * @param value the value of the {@code HttpCookie} given a key
+   */
+  public void setCookie(String url, String key, String value) {
+    String cookieValue = key + "=" + value;
+    setCookie(url, cookieValue);
+  }
+
+  /**
+   * Removes all cookies. This method is asynchronous.
+   */
+  public void removeAllCookies() {
+    webkitCookieManager.removeAllCookies(null);
+    flush();
+  }
+
+  /**
+   * Ensures all cookies currently accessible through the getCookie API are written to persistent
+   *  storage. This call will block the caller until it is done and may perform I/O.
+   */
+  public void flush() {
+    webkitCookieManager.flush();
+  }
+
+  @Override
+  public void put(URI uri, Map<String, List<String>> responseHeaders) {
+    // make sure our args are valid
+    if ((uri == null) || (responseHeaders == null)) return;
+
+    // save our url once
+    String url = uri.toString();
+
+    // go over the headers
+    for (String headerKey : responseHeaders.keySet()) {
+      // ignore headers which aren't cookie related
+      if ((headerKey == null) || !(headerKey.equalsIgnoreCase("Set-Cookie2") || headerKey.equalsIgnoreCase("Set-Cookie"))) continue;
+
+      // process each of the headers
+      for (String headerValue : Objects.requireNonNull(responseHeaders.get(headerKey))) {
+        setCookie(url, headerValue);
+      }
+    }
+  }
+
+  @Override
+  public Map<String, List<String>> get(URI uri, Map<String, List<String>> requestHeaders) {
+    // make sure our args are valid
+    if ((uri == null) || (requestHeaders == null)) throw new IllegalArgumentException("Argument is null");
+
+    // save our url once
+    String url = uri.toString();
+
+    // prepare our response
+    Map<String, List<String>> res = new HashMap<>();
+
+    // get the cookie
+    String cookie = getCookieString(url);
+
+    // return it
+    if (cookie != null) res.put("Cookie", Collections.singletonList(cookie));
+    return res;
+  }
+
+  @Override
+  public CookieStore getCookieStore() {
+    // we don't want anyone to work with this cookie store directly
+    throw new UnsupportedOperationException();
+  }
+}