manishk3008 · December 29, 2020 09:17 · Nov 16, 2019 · Sep 13, 2014 · Sep 13, 2014 · Sep 13, 2014
diff --git a/ANdroid Persitent Cookie Store → Android Persistent Cookies Store b/ANdroid Persitent Cookie Store → Android Persistent Cookies Store
diff --git a/SICookie2 b/SICookie2
@@ -1,5 +1,5 @@
 /**
- * 
+ * Taken from https://github.com/loopj/android-async-http
  */
 package com.orb.net;
 

diff --git a/SiCookieStore2 b/SiCookieStore2
@@ -1,5 +1,5 @@
 /**
- * 
+ * Inspired from https://github.com/loopj/android-async-http
  */
 package com.orb.net;
 

diff --git a/ANdroid Persitent Cookie Store b/ANdroid Persitent Cookie Store
@@ -1,3 +1,4 @@
+//HOW TO USE
 SiCookieStore2 siCookieStore = new SiCookieStore2(context);
 CookieManager cookieManager = new CookieManager((CookieStore) siCookieStore, CookiePolicy.ACCEPT_ALL);
 CookieHandler.setDefault(cookieManager);
diff --git a/How to use → ANdroid Persitent Cookie Store b/How to use → ANdroid Persitent Cookie Store
diff --git a/How to use b/How to use
@@ -0,0 +1,3 @@
+SiCookieStore2 siCookieStore = new SiCookieStore2(context);
+CookieManager cookieManager = new CookieManager((CookieStore) siCookieStore, CookiePolicy.ACCEPT_ALL);
+CookieHandler.setDefault(cookieManager);
diff --git a/SICookie2 b/SICookie2
@@ -0,0 +1,66 @@
+/**
+ * 
+ */
+package com.orb.net;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.net.HttpCookie;
+
+/**
+ * A simple wrapper for {@link HttpCookie} to work with {@link SiCookieStore2}
+ * Gives power of serialization-deserialization to {@link HttpCookie}
+ * @author Manish
+ * 
+ */
+public class SICookie2 implements Serializable {
+
+	private HttpCookie mHttpCookie;
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 2532101328282342578L;
+
+	/**
+	 * 
+	 */
+	public SICookie2(HttpCookie cookie) {
+		this.mHttpCookie = cookie;
+	}
+
+	public HttpCookie getCookie() {
+		return mHttpCookie;
+	}
+
+	private void writeObject(ObjectOutputStream out) throws IOException {
+		out.writeObject(mHttpCookie.getName());
+		out.writeObject(mHttpCookie.getValue());
+		out.writeObject(mHttpCookie.getComment());
+		out.writeObject(mHttpCookie.getCommentURL());
+		out.writeBoolean(mHttpCookie.getDiscard());
+		out.writeObject(mHttpCookie.getDomain());
+		out.writeLong(mHttpCookie.getMaxAge());
+		out.writeObject(mHttpCookie.getPath());
+		out.writeObject(mHttpCookie.getPortlist());
+		out.writeBoolean(mHttpCookie.getSecure());
+		out.writeInt(mHttpCookie.getVersion());
+	}
+
+	private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
+		String name = (String) in.readObject();
+		String value = (String) in.readObject();
+		mHttpCookie = new HttpCookie(name, value);
+		mHttpCookie.setComment((String) in.readObject());
+		mHttpCookie.setCommentURL((String) in.readObject());
+		mHttpCookie.setDiscard(in.readBoolean());
+		mHttpCookie.setDomain((String) in.readObject());
+		mHttpCookie.setMaxAge(in.readLong());
+		mHttpCookie.setPath((String) in.readObject());
+		mHttpCookie.setPortlist((String) in.readObject());
+		mHttpCookie.setSecure(in.readBoolean());
+		mHttpCookie.setVersion(in.readInt());
+	}
+
+}
diff --git a/SiCookieStore2 b/SiCookieStore2
@@ -0,0 +1,491 @@
+/**
+ * 
+ */
+package com.orb.net;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.CookieStore;
+import java.net.HttpCookie;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.text.TextUtils;
+
+import com.orb.common.Log;
+
+/**
+ * Implementation of {@link CookieStore} for persistence cookies, uses shared
+ * preference for storing cookies.
+ * 
+ * @author Manish
+ * 
+ */
+public class SiCookieStore2 implements CookieStore {
+	private static final String LOG_TAG = "SICookieStore2";
+	private static final String COOKIE_PREFS = "com.orb.net.cookieprefs";
+	private static final String COOKIE_DOMAINS_STORE = "com.orb.net.CookieStore.domain";
+	private static final String COOKIE_DOMAIN_PREFIX = "com.orb.net.CookieStore.domain_";
+	private static final String COOKIE_NAME_PREFIX = "com.orb.net.CookieStore.cookie_";
+
+	/*This map here will store all domain to cookies bindings*/
+	private final CookieMap map;
+
+	private final SharedPreferences cookiePrefs;
+
+	/**
+	 * Construct a persistent cookie store.
+	 * 
+	 * @param context
+	 *            Context to attach cookie store to
+	 */
+	public SiCookieStore2(Context context) {
+		cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
+		map = new CookieMap();
+
+		// Load any previously stored domains into the store
+		String storedCookieDomains = cookiePrefs.getString(COOKIE_DOMAINS_STORE, null);
+		if (storedCookieDomains != null) {
+			String[] storedCookieDomainsArray = TextUtils.split(storedCookieDomains, ",");
+			//split this domains and get cookie names stored for each domain
+			for (String domain : storedCookieDomainsArray) {
+				String storedCookiesNames = cookiePrefs.getString(COOKIE_DOMAIN_PREFIX + domain,
+						null);
+				//so now we have these cookie names
+				if (storedCookiesNames != null) {
+					//split these cookie names and get serialized cookie stored
+					String[] storedCookieNamesArray = TextUtils.split(storedCookiesNames, ",");
+					if (storedCookieNamesArray != null) {
+						//in this list we store all cookies under one URI
+						List<HttpCookie> cookies = new ArrayList<HttpCookie>();
+						for (String cookieName : storedCookieNamesArray) {
+							String encCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + domain
+									+ cookieName, null);
+							//now we deserialize or unserialize (whatever you call it) this cookie 
+							//and get HttpCookie out of it and pass it to List
+							if (encCookie != null)
+								cookies.add(decodeCookie(encCookie));
+						}
+						map.put(URI.create(domain), cookies);
+					}
+				}
+			}
+		}
+	}
+
+	public synchronized void add(URI uri, HttpCookie cookie) {
+		if (cookie == null) {
+			throw new NullPointerException("cookie == null");
+		}
+
+		uri = cookiesUri(uri);
+		List<HttpCookie> cookies = map.get(uri);
+		if (cookies == null) {
+			cookies = new ArrayList<HttpCookie>();
+			map.put(uri, cookies);
+		} else {
+			cookies.remove(cookie);
+		}
+		cookies.add(cookie);
+
+		// Save cookie into persistent store
+		SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
+		prefsWriter.putString(COOKIE_DOMAINS_STORE, TextUtils.join(",", map.keySet()));
+
+		Set<String> names = new HashSet<String>();
+		for (HttpCookie cookie2 : cookies) {
+			names.add(cookie2.getName());
+			prefsWriter.putString(COOKIE_NAME_PREFIX + uri + cookie2.getName(),
+					encodeCookie(new SICookie2(cookie2)));
+		}
+		prefsWriter.putString(COOKIE_DOMAIN_PREFIX + uri, TextUtils.join(",", names));
+
+		prefsWriter.commit();
+	}
+
+	public synchronized List<HttpCookie> get(URI uri) {
+		if (uri == null) {
+			throw new NullPointerException("uri == null");
+		}
+
+		List<HttpCookie> result = new ArrayList<HttpCookie>();
+		// get cookies associated with given URI. If none, returns an empty list
+		List<HttpCookie> cookiesForUri = map.get(uri);
+		if (cookiesForUri != null) {
+			for (Iterator<HttpCookie> i = cookiesForUri.iterator(); i.hasNext();) {
+				HttpCookie cookie = i.next();
+				if (cookie.hasExpired()) {
+					i.remove(); // remove expired cookies
+				} else {
+					result.add(cookie);
+				}
+			}
+		}
+		// get all cookies that domain matches the URI
+		for (Map.Entry<URI, List<HttpCookie>> entry : map.entrySet()) {
+			if (uri.equals(entry.getKey())) {
+				continue; // skip the given URI; we've already handled it
+			}
+			List<HttpCookie> entryCookies = entry.getValue();
+			for (Iterator<HttpCookie> i = entryCookies.iterator(); i.hasNext();) {
+				HttpCookie cookie = i.next();
+				if (!HttpCookie.domainMatches(cookie.getDomain(), uri.getHost())) {
+					continue;
+				}
+				if (cookie.hasExpired()) {
+					i.remove(); // remove expired cookies
+				} else if (!result.contains(cookie)) {
+					result.add(cookie);
+				}
+			}
+		}
+		return Collections.unmodifiableList(result);
+	}
+
+	public synchronized List<HttpCookie> getCookies() {
+		List<HttpCookie> result = new ArrayList<HttpCookie>();
+		for (List<HttpCookie> list : map.values()) {
+			for (Iterator<HttpCookie> i = list.iterator(); i.hasNext();) {
+				HttpCookie cookie = i.next();
+				if (cookie.hasExpired()) {
+					i.remove(); // remove expired cookies
+				} else if (!result.contains(cookie)) {
+					result.add(cookie);
+				}
+			}
+		}
+		return Collections.unmodifiableList(result);
+	}
+
+	public synchronized List<URI> getURIs() {
+		List<URI> result = new ArrayList<URI>(map.getAllURIs());
+		result.remove(null); // sigh
+		return Collections.unmodifiableList(result);
+	}
+
+
+	public synchronized boolean remove(URI uri, HttpCookie cookie) {
+		if (cookie == null) {
+			throw new NullPointerException("cookie == null");
+		}
+
+		if (map.removeCookie(uri, cookie)) {
+			SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
+			prefsWriter.putString(COOKIE_DOMAIN_PREFIX + uri,
+					TextUtils.join(",", map.getAllCookieNames(uri)));
+			prefsWriter.remove(COOKIE_NAME_PREFIX + uri + cookie.getName());
+			prefsWriter.apply();
+			return true;
+		}
+		return false;
+	}
+
+	public synchronized boolean removeAll() {
+		// Clear cookies from persistent store
+		SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
+		prefsWriter.clear();
+		prefsWriter.commit();
+
+		// Clear cookies from local store
+		boolean result = !map.isEmpty();
+		map.clear();
+		return result;
+	}
+
+	/**
+	 * Serializes HttpCookie object into String
+	 * 
+	 * @param cookie
+	 *            cookie to be encoded, can be null
+	 * @return cookie encoded as String
+	 */
+	protected String encodeCookie(SICookie2 cookie) {
+		if (cookie == null)
+			return null;
+
+		ByteArrayOutputStream os = new ByteArrayOutputStream();
+		try {
+			ObjectOutputStream outputStream = new ObjectOutputStream(os);
+			outputStream.writeObject(cookie);
+		} catch (IOException e) {
+			Log.e(LOG_TAG, "IOException in encodeCookie", e);
+			return null;
+		}
+
+		return byteArrayToHexString(os.toByteArray());
+	}
+
+	/**
+	 * Returns HttpCookie decoded from cookie string
+	 * 
+	 * @param cookieString
+	 *            string of cookie as returned from http request
+	 * @return decoded cookie or null if exception occured
+	 */
+	protected HttpCookie decodeCookie(String cookieString) {
+		byte[] bytes = hexStringToByteArray(cookieString);
+		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
+
+		HttpCookie cookie = null;
+		try {
+			ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
+			cookie = ((SICookie2) objectInputStream.readObject()).getCookie();
+		} catch (IOException e) {
+			Log.e(LOG_TAG, "IOException in decodeCookie", e);
+		} catch (ClassNotFoundException e) {
+			Log.e(LOG_TAG, "ClassNotFoundException in decodeCookie", e);
+		}
+
+		return cookie;
+	}
+
+	/**
+	 * Using some super basic byte array &lt;-&gt; hex conversions so we don't
+	 * have to rely on any large Base64 libraries. Can be overridden if you
+	 * like!
+	 * 
+	 * @param bytes
+	 *            byte array to be converted
+	 * @return string containing hex values
+	 */
+	protected String byteArrayToHexString(byte[] bytes) {
+		StringBuilder sb = new StringBuilder(bytes.length * 2);
+		for (byte element : bytes) {
+			int v = element & 0xff;
+			if (v < 16) {
+				sb.append('0');
+			}
+			sb.append(Integer.toHexString(v));
+		}
+		return sb.toString().toUpperCase(Locale.US);
+	}
+
+	/**
+	 * Converts hex values from strings to byte arra
+	 * 
+	 * @param hexString
+	 *            string of hex-encoded values
+	 * @return decoded byte array
+	 */
+	protected byte[] hexStringToByteArray(String hexString) {
+		int len = hexString.length();
+		byte[] data = new byte[len / 2];
+		for (int i = 0; i < len; i += 2) {
+			data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) + Character
+					.digit(hexString.charAt(i + 1), 16));
+		}
+		return data;
+	}
+	/**
+	 * Utility function to male sure that every time you get consistent URI 
+	 * @param uri
+	 * @return
+	 */
+	private URI cookiesUri(URI uri) {
+		if (uri == null) {
+			return null;
+		}
+		try {
+			return new URI(uri.getScheme(), uri.getHost(), null, null);
+		} catch (URISyntaxException e) {
+			return uri;
+		}
+	}
+	/**
+	 * A implementation of {@link Map} for utility class for storing URL cookie map
+	 * @author Manish
+	 *
+	 */
+	private class CookieMap implements Map<URI, List<HttpCookie>> {
+
+		private final Map<URI, List<HttpCookie>> map;
+
+		/**
+		 * 
+		 */
+		public CookieMap() {
+			map = new HashMap<URI, List<HttpCookie>>();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#clear()
+		 */
+		@Override
+		public void clear() {
+			map.clear();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#containsKey(java.lang.Object)
+		 */
+		@Override
+		public boolean containsKey(Object key) {
+
+			return map.containsKey(key);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#containsValue(java.lang.Object)
+		 */
+		@Override
+		public boolean containsValue(Object value) {
+
+			return map.containsValue(value);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#entrySet()
+		 */
+		@Override
+		public Set<java.util.Map.Entry<URI, List<HttpCookie>>> entrySet() {
+
+			return map.entrySet();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#get(java.lang.Object)
+		 */
+		@Override
+		public List<HttpCookie> get(Object key) {
+
+			return map.get(key);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#isEmpty()
+		 */
+		@Override
+		public boolean isEmpty() {
+
+			return map.isEmpty();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#keySet()
+		 */
+		@Override
+		public Set<URI> keySet() {
+
+			return map.keySet();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#put(java.lang.Object, java.lang.Object)
+		 */
+		@Override
+		public List<HttpCookie> put(URI key, List<HttpCookie> value) {
+
+			return map.put(key, value);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#putAll(java.util.Map)
+		 */
+		@Override
+		public void putAll(Map<? extends URI, ? extends List<HttpCookie>> map) {
+			this.map.putAll(map);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#remove(java.lang.Object)
+		 */
+		@Override
+		public List<HttpCookie> remove(Object key) {
+
+			return map.remove(key);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#size()
+		 */
+		@Override
+		public int size() {
+
+			return map.size();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * 
+		 * @see java.util.Map#values()
+		 */
+		@Override
+		public Collection<List<HttpCookie>> values() {
+
+			return map.values();
+		}
+		/**
+		 * List all URIs for which cookies are stored in map
+		 * @return
+		 */
+		public Collection<URI> getAllURIs() {
+			return map.keySet();
+		}
+		/**
+		 * Get all cookies names stored for given URI
+		 * @param uri
+		 * @return
+		 */
+		public Collection<String> getAllCookieNames(URI uri) {
+			List<HttpCookie> cookies = map.get(uri);
+			Set<String> cookieNames = new HashSet<String>();
+			for (HttpCookie cookie : cookies) {
+				cookieNames.add(cookie.getName());
+			}
+			return cookieNames;
+		}
+		/**
+		 * Removes requested {@link HttpCookie} {@code httpCookie} from given {@code uri} value
+		 * @param uri
+		 * @param httpCookie
+		 * @return
+		 */
+		public boolean removeCookie(URI uri, HttpCookie httpCookie) {
+			if (map.containsKey(uri)) {
+				return map.get(uri).remove(httpCookie);
+			} else {
+				return false;
+			}
+
+		}
+
+	}
+}