Java tutorial
/* * Copyright (C) 2013 www.418log.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.ab.http; import android.content.Context; import android.content.SharedPreferences; import android.text.TextUtils; import org.apache.http.client.CookieStore; import org.apache.http.cookie.Cookie; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.concurrent.ConcurrentHashMap; // TODO: Auto-generated Javadoc /** * A persistent cookie store which implements the Apache HttpClient. * * {@link CookieStore} interface. Cookies are stored and will persist on the * user's device between application sessions since they are serialized and * stored in {@link SharedPreferences}. * <p> </p> * Instances of this class are designed to be used with * {@link AsyncHttpClient#setCookieStore}, but can also be used with a * regular old apache HttpClient/HttpContext if you prefer. */ public class PersistentCookieStore implements CookieStore { /** The Constant COOKIE_PREFS. */ private static final String COOKIE_PREFS = "CookiePrefsFile"; /** The Constant COOKIE_NAME_STORE. */ private static final String COOKIE_NAME_STORE = "names"; /** The Constant COOKIE_NAME_PREFIX. */ private static final String COOKIE_NAME_PREFIX = "cookie_"; /** The cookies. */ private final ConcurrentHashMap<String, Cookie> cookies; /** The cookie prefs. */ private final SharedPreferences cookiePrefs; /** * Construct a persistent cookie store. * * @param context Context to attach cookie store to */ public PersistentCookieStore(Context context) { cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0); cookies = new ConcurrentHashMap<String, Cookie>(); // Load any previously stored cookies into the store String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE, null); if (storedCookieNames != null) { String[] cookieNames = TextUtils.split(storedCookieNames, ","); for (String name : cookieNames) { String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX + name, null); if (encodedCookie != null) { Cookie decodedCookie = decodeCookie(encodedCookie); if (decodedCookie != null) { cookies.put(name, decodedCookie); } } } // Clear out expired cookies clearExpired(new Date()); } } /** * ??TODO * @see org.apache.http.client.CookieStore#addCookie(org.apache.http.cookie.Cookie) * @author: zhaoqp * @date2013-10-22 ?4:23:15 * @version v1.0 */ @Override public void addCookie(Cookie cookie) { String name = cookie.getName() + cookie.getDomain(); // Save cookie into local store, or remove if expired if (!cookie.isExpired(new Date())) { cookies.put(name, cookie); } else { cookies.remove(name); } // Save cookie into persistent store SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet())); prefsWriter.putString(COOKIE_NAME_PREFIX + name, encodeCookie(new SerializableCookie(cookie))); prefsWriter.commit(); } /** * ??TODO * @see org.apache.http.client.CookieStore#clear() * @author: zhaoqp * @date2013-10-22 ?4:23:15 * @version v1.0 */ @Override public void clear() { // Clear cookies from persistent store SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); for (String name : cookies.keySet()) { prefsWriter.remove(COOKIE_NAME_PREFIX + name); } prefsWriter.remove(COOKIE_NAME_STORE); prefsWriter.commit(); // Clear cookies from local store cookies.clear(); } /** * ??TODO * @see org.apache.http.client.CookieStore#clearExpired(java.util.Date) * @author: zhaoqp * @date2013-10-22 ?4:23:15 * @version v1.0 */ @Override public boolean clearExpired(Date date) { boolean clearedAny = false; SharedPreferences.Editor prefsWriter = cookiePrefs.edit(); for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) { String name = entry.getKey(); Cookie cookie = entry.getValue(); if (cookie.isExpired(date)) { // Clear cookies from local store cookies.remove(name); // Clear cookies from persistent store prefsWriter.remove(COOKIE_NAME_PREFIX + name); // We've cleared at least one clearedAny = true; } } // Update names in persistent store if (clearedAny) { prefsWriter.putString(COOKIE_NAME_STORE, TextUtils.join(",", cookies.keySet())); } prefsWriter.commit(); return clearedAny; } /** * ??TODO * @see org.apache.http.client.CookieStore#getCookies() * @author: zhaoqp * @date2013-10-22 ?4:23:15 * @version v1.0 */ @Override public List<Cookie> getCookies() { return new ArrayList<Cookie>(cookies.values()); } // // Cookie serialization/deserialization // /** * Encode cookie. * * @param cookie the cookie * @return the string */ protected String encodeCookie(SerializableCookie cookie) { ByteArrayOutputStream os = new ByteArrayOutputStream(); try { ObjectOutputStream outputStream = new ObjectOutputStream(os); outputStream.writeObject(cookie); } catch (Exception e) { return null; } return byteArrayToHexString(os.toByteArray()); } /** * Decode cookie. * * @param cookieStr the cookie str * @return the cookie */ protected Cookie decodeCookie(String cookieStr) { byte[] bytes = hexStringToByteArray(cookieStr); ByteArrayInputStream is = new ByteArrayInputStream(bytes); Cookie cookie = null; try { ObjectInputStream ois = new ObjectInputStream(is); cookie = ((SerializableCookie) ois.readObject()).getCookie(); } catch (Exception e) { e.printStackTrace(); } return cookie; } // Using some super basic byte array <-> hex conversions so we don't have // to rely on any large Base64 libraries. Can be overridden if you like! /** * Byte array to hex string. * * @param b the b * @return the string */ protected String byteArrayToHexString(byte[] b) { StringBuilder sb = new StringBuilder(b.length * 2); for (byte element : b) { int v = element & 0xff; if (v < 16) { sb.append('0'); } sb.append(Integer.toHexString(v)); } return sb.toString().toUpperCase(); } /** * Hex string to byte array. * * @param s the s * @return the byte[] */ protected byte[] hexStringToByteArray(String s) { int len = s.length(); byte[] data = new byte[len / 2]; for (int i = 0; i < len; i += 2) { data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16)); } return data; } }