add isConnecionKeepAlive

to set whether http connecion is keep alive when get images from network

Author: Trinea

src/cn/trinea/android/common/service/impl/ImageCache.java

@@ -229,6 +229,16 @@ public void setContext(Context context) {
         secondaryCache.setContext(context);
     }
 
+    @Override
+    public boolean isConnecionKeepAlive() {
+        return secondaryCache.isConnecionKeepAlive();
+    }
+
+    @Override
+    public void setConnecionKeepAlive(boolean isConnecionKeepAlive) {
+        secondaryCache.setConnecionKeepAlive(isConnecionKeepAlive);
+    }
+
     /**
      * get cache folder path which be used when saving images, default is {@link #DEFAULT_CACHE_FOLDER}
      * 

src/cn/trinea/android/common/service/impl/ImageMemoryCache.java

@@ -56,27 +56,29 @@
  */
 public class ImageMemoryCache extends PreloadDataCache<String, Drawable> {
 
-    private static final long                    serialVersionUID   = 1L;
+    private static final long                    serialVersionUID     = 1L;
 
-    private static final String                  TAG                = "ImageCache";
+    private static final String                  TAG                  = "ImageCache";
 
     /** callback interface after image get success **/
     private OnImageCallbackListener              onImageCallbackListener;
     /** http read image time out, if less than 0, not set. default is not set **/
-    private int                                  httpReadTimeOut    = -1;
+    private int                                  httpReadTimeOut      = -1;
     /**
      * whether open waiting queue, default is true. If true, save all view waiting for image loaded, else only save the
      * newest one
      **/
-    private boolean                              isOpenWaitingQueue = true;
+    private boolean                              isOpenWaitingQueue   = true;
+    /** whether http connecion is keep alive **/
+    private boolean                              isConnecionKeepAlive = true;
 
     /** recommend default max cache size according to dalvik max memory **/
-    public static final int                      DEFAULT_MAX_SIZE   = getDefaultMaxSize();
+    public static final int                      DEFAULT_MAX_SIZE     = getDefaultMaxSize();
     /** image got success message what **/
-    private static final int                     IMAGE_LOADED_WHAT  = 1;
+    private static final int                     IMAGE_LOADED_WHAT    = 1;
 
     /** thread pool whose wait for data got, attention, not the get data thread pool **/
-    private transient ExecutorService            threadPool         = Executors.newFixedThreadPool(SystemUtils.DEFAULT_THREAD_POOL_SIZE);
+    private transient ExecutorService            threadPool           = Executors.newFixedThreadPool(SystemUtils.DEFAULT_THREAD_POOL_SIZE);
     /**
      * key is image url, value is the newest view which waiting for image loaded, used when {@link #isOpenWaitingQueue}
      * is false
@@ -209,6 +211,29 @@ public void setOpenWaitingQueue(boolean isOpenWaitingQueue) {
         this.isOpenWaitingQueue = isOpenWaitingQueue;
     }
 
+    /**
+     * get whether http connecion is keep alive
+     * 
+     * @return the isConnecionKeepAlive
+     */
+    public boolean isConnecionKeepAlive() {
+        return isConnecionKeepAlive;
+    }
+
+    /**
+     * set whether http connecion is keep alive
+     * <ul>
+     * <li>if image is from the same server, isConnecionKeepAlive is set to true recommended, and this is the default
+     * value</li>
+     * <li>else if image is from the different server, isConnecionKeepAlive is set to false recommended</li>
+     * </ul>
+     * 
+     * @param isConnecionKeepAlive the isConnecionKeepAlive to set
+     */
+    public void setConnecionKeepAlive(boolean isConnecionKeepAlive) {
+        this.isConnecionKeepAlive = isConnecionKeepAlive;
+    }
+
     /**
      * <ul>
      * <li>Get data listener is {@link #getDefaultOnGetImageListener()}</li>
@@ -407,7 +432,7 @@ public OnGetDataListener<String, Drawable> getDefaultOnGetImageListener() {
             public CacheObject<Drawable> onGetData(String key) {
                 Drawable d = null;
                 try {
-                    d = ImageUtils.getDrawableFromUrl(key, httpReadTimeOut);
+                    d = ImageUtils.getDrawableFromUrl(key, httpReadTimeOut, isConnecionKeepAlive);
                 } catch (Exception e) {
                     Log.e(TAG, "get drawable exception, imageUrl is:" + key, e);
                 }

src/cn/trinea/android/common/service/impl/ImageSDCardCache.java

@@ -84,6 +84,8 @@ public class ImageSDCardCache extends PreloadDataCache<String, String> {
      * newest one
      **/
     private boolean                              isOpenWaitingQueue   = true;
+    /** whether http connecion is keep alive **/
+    private boolean                              isConnecionKeepAlive = true;
 
     /** recommend default max cache size according to dalvik max memory **/
     public static final int                      DEFAULT_MAX_SIZE     = getDefaultMaxSize();
@@ -277,6 +279,29 @@ public void setOpenWaitingQueue(boolean isOpenWaitingQueue) {
         this.isOpenWaitingQueue = isOpenWaitingQueue;
     }
 
+    /**
+     * get whether http connecion is keep alive
+     * 
+     * @return the isConnecionKeepAlive
+     */
+    public boolean isConnecionKeepAlive() {
+        return isConnecionKeepAlive;
+    }
+
+    /**
+     * set whether http connecion is keep alive
+     * <ul>
+     * <li>if image is from the same server, isConnecionKeepAlive is set to true recommended, and this is the default
+     * value</li>
+     * <li>else if image is from the different server, isConnecionKeepAlive is set to false recommended</li>
+     * </ul>
+     * 
+     * @param isConnecionKeepAlive the isConnecionKeepAlive to set
+     */
+    public void setConnecionKeepAlive(boolean isConnecionKeepAlive) {
+        this.isConnecionKeepAlive = isConnecionKeepAlive;
+    }
+
     /**
      * <ul>
      * <li>Get data listener is {@link #getDefaultOnGetImageListener()}</li>
@@ -678,7 +703,7 @@ public CacheObject<String> onGetData(String key) {
 
                 String savePath = null;
                 try {
-                    InputStream stream = ImageUtils.getInputStreamFromUrl(key, httpReadTimeOut);
+                    InputStream stream = ImageUtils.getInputStreamFromUrl(key, httpReadTimeOut, isConnecionKeepAlive);
                     if (stream != null) {
                         savePath = cacheFolder + File.separator + fileNameRule.getFileName(key);
                         try {

src/cn/trinea/android/common/util/ImageUtils.java

@@ -106,20 +106,38 @@ public static Drawable byteToDrawable(byte[] b) {
         return bitmapToDrawable(byteToBitmap(b));
     }
 
+    /**
+     * get input stream from network by imageurl, and http conection is keep alive, you need to close inputStream
+     * yourself
+     * 
+     * @param imageUrl
+     * @param readTimeOutMillis
+     * @return
+     * @see ImageUtils#getInputStreamFromUrl(String, int, boolean)
+     */
+    public static InputStream getInputStreamFromUrl(String imageUrl, int readTimeOutMillis) {
+        return getInputStreamFromUrl(imageUrl, readTimeOutMillis, true);
+    }
+
     /**
      * get input stream from network by imageurl, you need to close inputStream yourself
      * 
      * @param imageUrl
      * @param readTimeOutMillis read time out, if less than 0, not set, in mills
+     * @param isConnecionKeepAlive whether connection keep alive
      * @return
      * @throws MalformedURLException
      * @throws IOException
      */
-    public static InputStream getInputStreamFromUrl(String imageUrl, int readTimeOutMillis) {
+    public static InputStream getInputStreamFromUrl(String imageUrl, int readTimeOutMillis, boolean isConnecionKeepAlive) {
         InputStream stream = null;
         try {
             URL url = new URL(imageUrl);
             HttpURLConnection con = (HttpURLConnection)url.openConnection();
+            // default is keep alive
+            if (!isConnecionKeepAlive) {
+                con.addRequestProperty("Connection", "false");
+            }
             if (readTimeOutMillis > 0) {
                 con.setReadTimeout(readTimeOutMillis);
             }
@@ -134,28 +152,54 @@ public static InputStream getInputStreamFromUrl(String imageUrl, int readTimeOut
         return stream;
     }
 
+    /**
+     * get drawable by imageUrl , and http conection is keep alive
+     * 
+     * @param imageUrl
+     * @param readTimeOutMillis
+     * @return
+     * @see ImageUtils#getDrawableFromUrl(String, int, boolean)
+     */
+    public static Drawable getDrawableFromUrl(String imageUrl, int readTimeOutMillis) {
+        return getDrawableFromUrl(imageUrl, readTimeOutMillis, true);
+    }
+
     /**
      * get drawable by imageUrl
      * 
      * @param imageUrl
      * @param readTimeOutMillis read time out, if less than 0, not set, in mills
+     * @param isConnecionKeepAlive whether connection keep alive
      * @return
      */
-    public static Drawable getDrawableFromUrl(String imageUrl, int readTimeOutMillis) {
-        InputStream stream = getInputStreamFromUrl(imageUrl, readTimeOutMillis);
+    public static Drawable getDrawableFromUrl(String imageUrl, int readTimeOutMillis, boolean isConnecionKeepAlive) {
+        InputStream stream = getInputStreamFromUrl(imageUrl, readTimeOutMillis, isConnecionKeepAlive);
         Drawable d = Drawable.createFromStream(stream, "src");
         closeInputStream(stream);
         return d;
     }
 
     /**
-     * get Bitmap by imageUrl
+     * get Bitmap by imageUrl, and http conection is keep alive
      * 
      * @param imageUrl
+     * @param readTimeOut
      * @return
+     * @see ImageUtils#getBitmapFromUrl(String, int, boolean)
      */
     public static Bitmap getBitmapFromUrl(String imageUrl, int readTimeOut) {
-        InputStream stream = getInputStreamFromUrl(imageUrl, readTimeOut);
+        return getBitmapFromUrl(imageUrl, readTimeOut, true);
+    }
+
+    /**
+     * get Bitmap by imageUrl
+     * 
+     * @param imageUrl
+     * @param isConnecionKeepAlive whether connection keep alive
+     * @return
+     */
+    public static Bitmap getBitmapFromUrl(String imageUrl, int readTimeOut, boolean isConnecionKeepAlive) {
+        InputStream stream = getInputStreamFromUrl(imageUrl, readTimeOut, isConnecionKeepAlive);
         Bitmap b = BitmapFactory.decodeStream(stream);
         closeInputStream(stream);
         return b;