path: root/app/src/main/java/uk/co/blatech/blaupload/ui/NetworkCacheableImageView.java

/*******************************************************************************
 * Copyright (c) 2013 Chris Banes.
 *
 * 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 uk.co.blatech.blaupload.ui;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.graphics.drawable.BitmapDrawable;
import android.opengl.GLES10;
import android.os.AsyncTask;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.ImageView;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.WeakReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.RejectedExecutionException;

import javax.microedition.khronos.opengles.GL10;

import uk.co.blatech.blaupload.BlauploadApplication;
import uk.co.blatech.blaupload.R;
import uk.co.blatech.blaupload.data.ImageItem;
import uk.co.senab.bitmapcache.BitmapLruCache;
import uk.co.senab.bitmapcache.CacheableBitmapDrawable;
import uk.co.senab.bitmapcache.CacheableImageView;

/**
 * Simple extension of CacheableImageView which allows downloading of Images of the Internet.
 *
 * This code isn't production quality, but works well enough for this sample.s
 *
 * @author Chris Banes
 */
public class NetworkCacheableImageView extends CacheableImageView {

    public interface OnImageLoadedListener {
        void onImageLoaded(CacheableBitmapDrawable result);
    }

    /**
     * This task simply fetches an Bitmap from the specified URL and wraps it in a wrapper. This
     * implementation is NOT 'best practice' or production ready code.
     */
    private static class ImageUrlAsyncTask
            extends AsyncTask<String, Void, CacheableBitmapDrawable> {

        private final BitmapLruCache mCache;

        private final WeakReference<ImageView> mImageViewRef;
        private final OnImageLoadedListener mListener;

        private final BitmapFactory.Options mDecodeOpts;

        ImageUrlAsyncTask(ImageView imageView, BitmapLruCache cache,
                          BitmapFactory.Options decodeOpts, OnImageLoadedListener listener) {
            mCache = cache;
            mImageViewRef = new WeakReference<ImageView>(imageView);
            mListener = listener;
            mDecodeOpts = decodeOpts;
        }

        @Override
        protected CacheableBitmapDrawable doInBackground(String... params) {

                // Return early if the ImageView has disappeared.
                if (null == mImageViewRef.get()) {
                    return null;
                }

                final String url = params[0];

                // Now we're not on the main thread we can check all caches
                CacheableBitmapDrawable result = mCache.get(url);

                if (null == result) {
                    Log.d("ImageUrlAsyncTask", "Downloading: " + url);

//                    // The bitmap isn't cached so download from the web
//                    HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
//                    InputStream is = new BufferedInputStream(conn.getInputStream());
                    Bitmap bmp = downloadImage(url);
                    // Add to cache
                    if (bmp != null) {
                        result = mCache.put(url, bmp);
                    }
                } else {
                    Log.d("ImageUrlAsyncTask", "Got from Cache: " + url);
                }

                return result;


        }

        @Override
        protected void onPostExecute(CacheableBitmapDrawable result) {
            super.onPostExecute(result);

            ImageView iv = mImageViewRef.get();
            if (null != iv) {
                iv.setImageDrawable(result);
            }

            if (null != mListener) {
                mListener.onImageLoaded(result);
            }
        }

        private Bitmap downloadImage(String url) {


            DefaultHttpClient client = new DefaultHttpClient();
            HttpGet httpGet = new HttpGet(url);
            Bitmap bmp = null;


            int[] maxTextureSize = new int[1];
            maxTextureSize[0] = 4096;
            GLES10.glGetIntegerv(GL10.GL_MAX_TEXTURE_SIZE, maxTextureSize, 0);
            //TODO: Fix out of memory errors
            try {
                HttpResponse response = client.execute(httpGet);
                StatusLine statusLine = response.getStatusLine();
                int statusCode = statusLine.getStatusCode();
                String[] parts = url.split("\\.");
                String extension = parts[parts.length-1];
                //Create the Bitmap if the file exists
                if (statusCode == 200 && isImageExtension(extension)) {
                    // If the thumbnail wasn't found, show a placeholder
                    HttpEntity entity = response.getEntity();
                    byte[] bytes = EntityUtils.toByteArray(entity);
                    try {
                        bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
                    } catch (Exception e) {
                        Log.e(NetworkCacheableImageView.class.toString(), "Failed decoding " + url);
                        e.printStackTrace();
                        return bmp;
                    }
                    int bmpHeight = bmp.getHeight();
                    int bmpWidth = bmp.getWidth();
                    if (bmpWidth > maxTextureSize[0]) {

                        float ratio = (float)maxTextureSize[0]/(float)bmpWidth;
                        Matrix matrix = new Matrix();
                        bmpWidth = maxTextureSize[0];
                        bmpHeight = Math.round(bmpHeight * ratio);
                        matrix.postScale(ratio, ratio);
                        bmp = Bitmap.createBitmap(bmp, 0, 0, bmpWidth, bmpHeight, matrix, false);
                    } else if (bmpHeight > maxTextureSize[0]) {
                        float ratio = (float)maxTextureSize[0]/(float)bmpHeight;
                        bmpHeight = maxTextureSize[0];
                        bmpWidth = Math.round(bmpWidth * ratio);
                        Matrix matrix = new Matrix();
                        matrix.postScale(ratio, ratio);
                        bmp = Bitmap.createBitmap(bmp, 0, 0, bmpWidth, bmpHeight, matrix, false);
                    }
                } else {
                    //If the file doesn't exist, use the placeholder instead
//                    bmp = BitmapFactory.decodeResource(res, R.drawable.x);
                    return bmp;
                }

                //TODO: Error handling (Not sure how we get here)
            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return bmp;
        }

        private boolean isImageExtension(String extension) {
            if (extension.equalsIgnoreCase("jpeg") || extension.equalsIgnoreCase("jpg") ||
                    extension.equalsIgnoreCase("gif") || extension.equalsIgnoreCase("png")) {
                return true;
            } else {
                return false;
            }
        }
    }

    private final BitmapLruCache mCache;

    private ImageUrlAsyncTask mCurrentTask;

    public NetworkCacheableImageView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mCache = BlauploadApplication.getApplication(context).getBitmapCache();
    }

    /**
     * Loads the Bitmap.
     *
     * @param url      - URL of image
     * @param fullSize - Whether the image should be kept at the original size
     * @return true if the bitmap was found in the cache
     */
    public boolean loadImage(String url, final boolean fullSize, OnImageLoadedListener listener) {
        // First check whether there's already a task running, if so cancel it
        if (null != mCurrentTask) {
            mCurrentTask.cancel(true);
        }

        // Check to see if the memory cache already has the bitmap. We can
        // safely do
        // this on the main thread.
        BitmapDrawable wrapper = mCache.getFromMemoryCache(url);

        if (null != wrapper) {
            // The cache has it, so just display it
            setImageDrawable(wrapper);
            return true;
        } else {
            // Memory Cache doesn't have the URL, do threaded request...
            setImageDrawable(null);

            BitmapFactory.Options decodeOpts = null;

            if (!fullSize) {
                //decodeOpts = new BitmapFactory.Options();
                //decodeOpts.inSampleSize = 2;
            }

            mCurrentTask = new ImageUrlAsyncTask(this, mCache, decodeOpts, listener);

            try {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                    mCurrentTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, url);
                } else {
                    mCurrentTask.execute(url);
                }
            } catch (RejectedExecutionException e) {
                // This shouldn't happen, but might.
            }

            return false;
        }
    }

}