图像加载器中的动画问题

时间:2011-12-14 02:02:29

标签: android listview animation adapter

我有一个ListView,其行可能有或没有图片。当有图片时,我会根据http://developer.android.com/resources/samples/XmlAdapters/src/com/example/android/xmladapters/ImageDownloader.html启动图像加载器。我的一个修改是在动画图像(旋转轮)加载图像时替换所显示的彩色绘图。为了做到这一点,我在构造函数中设置了一个微调器Bitmap,如果要下载的图像不在缓存中,我会在download(String url, ImageView imageView)方法中设置它。我在加载图像并将其设置为ImageView时清除动画。

问题在于动画代码

Animation rotate_picture = AnimationUtils.loadAnimation(context, R.anim.rotate_picture);
imageView.startAnimation(rotate_picture);

在我的ImageDownloader的download方法中,我的适配器变得疯狂,有时会将动画设置为下载的图像,或者将默认图片设置为没有图片的行。

当我评论这两行时,一切正常(除了旋转器当然没有动画)。

有人可以帮忙吗?

适配器的getView

@Override
public View getView(int position, View convertView, final ViewGroup parent) {
    View row = convertView;
    ItemHolder holder = null;

    if(row == null)
    {
        LayoutInflater inflater = ((Activity)context).getLayoutInflater();
        row = inflater.inflate(layoutResourceId, parent, false);

        holder = new ItemHolder();
        holder.title = (TextView)row.findViewById(R.id.title);
        holder.date = (TextView)row.findViewById(R.id.date);
        holder.desc = (EllipsizingTextView)row.findViewById(R.id.desc);
        holder.pic = (ImageView)row.findViewById(R.id.pic);    

        row.setTag(holder);
    }
    else
    {
        holder = (ItemHolder)row.getTag();
    }

    Item item = data.get(position);

    holder.title.setText(item.title);
    holder.date.setText(Utils.UnixTime2String(item.published, "/"));
    holder.desc.setMaxLines(3);
    holder.desc.setText(item.descriptionintro); 

    if(item.list_images.size()>0){
        holder.pic.setVisibility(View.VISIBLE);            
        imageLoader.download(GlobalData.BASE_URL + item.list_images.get(0), (ImageView) holder.pic);
    }
    else{
        holder.pic.setVisibility(View.GONE);
        holder.pic.setImageResource(0);
    }

    return row;
}

ImageDownloader

public class ImageDownloader {
    private static final String LOG_TAG = "ImageDownloader";

    private Integer xbound, ybound;

    private static Context context;
    private static Bitmap defaultPic;

    public ImageDownloader(Context context, Bitmap defaultPic, Integer xbound, Integer ybound){        
        ImageDownloader.context = context;
        ImageDownloader.defaultPic = defaultPic; 
        this.xbound = xbound;
        this.ybound = ybound;
    }

    /**
     * Download the specified image from the Internet and binds it to the provided ImageView. The
     * binding is immediate if the image is found in the cache and will be done asynchronously
     * otherwise. A null bitmap will be associated to the ImageView if an error occurs.
     *
     * @param url The URL of the image to download.
     * @param imageView The ImageView to bind the downloaded image to.
     */
    public void download(String url, ImageView imageView) {
        resetPurgeTimer();
        Bitmap bitmap = getBitmapFromCache(url);

        if (bitmap == null) { 
            //Animation rotate_picture = AnimationUtils.loadAnimation(context, R.anim.rotate_picture);
            //imageView.startAnimation(rotate_picture);
            forceDownload(url, imageView);
        } else {
            cancelPotentialDownload(url, imageView);
            imageView.setImageBitmap(bitmap);
        }
    }

    /*
     * Same as download but the image is always downloaded and the cache is not used.
     * Kept private at the moment as its interest is not clear.
      private void forceDownload(String url, ImageView view) {
         forceDownload(url, view, null);
      }
     */

    /**
     * Same as download but the image is always downloaded and the cache is not used.
     * Kept private at the moment as its interest is not clear.
     */
    private void forceDownload(String url, ImageView imageView) {
        // State sanity: url is guaranteed to never be null in DownloadedDrawable and cache keys.
        if (url == null) {
            imageView.setImageDrawable(null);
            return;
        }

        if (cancelPotentialDownload(url, imageView)) {

            BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
            DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task);
            imageView.setImageDrawable(downloadedDrawable);           
            task.execute(url);
        }
    }

    /**
     * Returns true if the current download has been canceled or if there was no download in
     * progress on this image view.
     * Returns false if the download in progress deals with the same url. The download is not
     * stopped in that case.
     */
    private static boolean cancelPotentialDownload(String url, ImageView imageView) {
        BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

        if (bitmapDownloaderTask != null) {
            String bitmapUrl = bitmapDownloaderTask.url;
            if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
                bitmapDownloaderTask.cancel(true);
            } else {
                // The same URL is already being downloaded.
                return false;
            }
        }
        return true;
    }

    /**
     * @param imageView Any imageView
     * @return Retrieve the currently active download task (if any) associated with this imageView.
     * null if there is no such task.
     */
    private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) {
        if (imageView != null) {
            Drawable drawable = imageView.getDrawable();
            if (drawable instanceof DownloadedDrawable) {
                DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable;
                return downloadedDrawable.getBitmapDownloaderTask();
            }
        }
        return null;
    }

    Bitmap downloadBitmap(String url) {
        //final int IO_BUFFER_SIZE = 4 * 1024;

        final HttpClient client = new DefaultHttpClient();
        final HttpGet getRequest = new HttpGet(url);

        try {
            HttpResponse response = client.execute(getRequest);
            final int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {              
                return null;
            }

            final HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream inputStream = null;
                try {
                    inputStream = entity.getContent();

                    return BitmapFactory.decodeStream(new FlushedInputStream(inputStream), null, null);
                } finally {
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    entity.consumeContent();
                }
            }
        } catch (IOException e) {
            getRequest.abort();           
        } catch (IllegalStateException e) {
            getRequest.abort();
        } catch (Exception e) {
            getRequest.abort();
        }
        return null;
    }    

    /*
     * Cancel and remove download task for a given ImageView. Done when going previous/next to avoid "out of memory" when clicking fast
     */

    void cancelDownload(ImageView imageView){
        BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
        if (bitmapDownloaderTask != null) {
            bitmapDownloaderTask.cancel(true); 
            removeBitmapDownloaderTask(imageView);
        }
    }


    private static boolean removeBitmapDownloaderTask(ImageView imageView) {
        if (imageView != null) {
            Drawable drawable = imageView.getDrawable();
            if (drawable instanceof DownloadedDrawable) {
                DownloadedDrawable downloadedDrawable = (DownloadedDrawable)drawable;
                downloadedDrawable.clearBitmapDownloaderTask();
                return true;
            }
        }
        return false;
    }


    /*
     * An InputStream that skips the exact number of bytes provided, unless it reaches EOF.
     */
    static class FlushedInputStream extends FilterInputStream {
        public FlushedInputStream(InputStream inputStream) {
            super(inputStream);
        }

        @Override
        public long skip(long n) throws IOException {
            long totalBytesSkipped = 0L;
            while (totalBytesSkipped < n) {
                long bytesSkipped = in.skip(n - totalBytesSkipped);
                if (bytesSkipped == 0L) {
                    int b = read();
                    if (b < 0) {
                        break;  // we reached EOF
                    } else {
                        bytesSkipped = 1; // we read one byte
                    }
                }
                totalBytesSkipped += bytesSkipped;
            }
            return totalBytesSkipped;
        }
    }

    /**
     * The actual AsyncTask that will asynchronously download the image.
     */
    class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
        private String url;
        private final WeakReference<ImageView> imageViewReference;

        public BitmapDownloaderTask(ImageView imageView) {           
            imageViewReference = new WeakReference<ImageView>(imageView);
        }

        /**
         * Actual download method.
         */
        @Override
        protected Bitmap doInBackground(String... params) {
            url = params[0];
            return downloadBitmap(url);
        }

        /**
         * Once the image is downloaded, associates it to the imageView
         */
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (isCancelled()) {
                bitmap = null;
            }

            if(bitmap != null ){ 

                addBitmapToCache(url, bitmap);

                if (imageViewReference != null) {
                    ImageView imageView = imageViewReference.get();
                    BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
                    // Change bitmap only if this process is still associated with it
                    // Or if we don't use any bitmap to task association (NO_DOWNLOADED_DRAWABLE mode)
                    if (this == bitmapDownloaderTask) {

                        if(xbound!=null && ybound!=null){

                            int width = bitmap.getWidth();
                            int height = bitmap.getHeight();
                            int xbounding = dpToPx(xbound);
                            int ybounding = dpToPx(ybound);

                            // Determine how much to scale: the dimension requiring less scaling is
                            // closer to the its side. This way the image always stays inside your
                            // bounding box AND either x/y axis touches it.  
                            float xScale = ((float) xbounding) / width;
                            float yScale = ((float) ybounding) / height;
                            float scale = (xScale <= yScale) ? xScale : yScale;

                            // Create a matrix for the scaling and add the scaling data
                            Matrix matrix = new Matrix();
                            matrix.postScale(scale, scale);

                            // Create a new bitmap and convert it to a format understood by the ImageView 
                            Bitmap scaledBitmap = Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
                            width = scaledBitmap.getWidth(); // re-use
                            height = scaledBitmap.getHeight(); // re-use
                            BitmapDrawable result = new BitmapDrawable(scaledBitmap);

                            // Apply the scaled bitmap
                            imageView.setImageDrawable(result);

                            // Now change ImageView's dimensions to match the scaled image
                            //LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) imageView.getLayoutParams(); 
                            //params.width = width;
                            //params.height = height;
                            //imageView.setLayoutParams(params);
                        }
                        else{
                            imageView.clearAnimation();
                            imageView.setImageBitmap(bitmap);                            
                        }

                    }
                }
            }
        }
    }

    private int dpToPx(int dp)
    {
        float density = context.getResources().getDisplayMetrics().density;
        return Math.round((float)dp * density);
    }


    /**
     * A fake Drawable that will be attached to the imageView while the download is in progress.
     *
     * <p>Contains a reference to the actual download task, so that a download task can be stopped
     * if a new binding is required, and makes sure that only the last started download process can
     * bind its result, independently of the download finish order.</p>
     */
    static class DownloadedDrawable extends BitmapDrawable {
        private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;

        public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
            super(context.getResources(), defaultPic);
            bitmapDownloaderTaskReference =
                new WeakReference<BitmapDownloaderTask>(bitmapDownloaderTask);
        }

        public BitmapDownloaderTask getBitmapDownloaderTask() {
            return bitmapDownloaderTaskReference.get();
        }   

        public void clearBitmapDownloaderTask() {
            bitmapDownloaderTaskReference.clear();
        }   
    }

    /*
     * 
     * Image loaded listener
     * 
     */

    OnImageDownloaderListener onImageDownloaderListener = null;    

    public interface OnImageDownloaderListener {
        public abstract void onImageLoaded(int tag);
    }

    public void setOnImageDownloaderListener(OnImageDownloaderListener listener) {
        onImageDownloaderListener = listener;
    }

    private void OnImageLoaded(int tag){
        if(onImageDownloaderListener!=null) {
            onImageDownloaderListener.onImageLoaded(tag);
        }
    }


    /*
     * Cache-related fields and methods.
     * 
     * We use a hard and a soft cache. A soft reference cache is too aggressively cleared by the
     * Garbage Collector.
     */

    private static final int HARD_CACHE_CAPACITY = 20;
    private static final int DELAY_BEFORE_PURGE = 10 * 1000; // in milliseconds

    // Hard cache, with a fixed maximum capacity and a life duration
    private final HashMap<String, Bitmap> sHardBitmapCache =
        new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY / 2, 0.75f, true) {
        @Override
        protected boolean removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {
            if (size() > HARD_CACHE_CAPACITY) {
                // Entries push-out of hard reference cache are transferred to soft reference cache
                sSoftBitmapCache.put(eldest.getKey(), new SoftReference<Bitmap>(eldest.getValue()));
                return true;
            } else
                return false;
        }
    };

    // Soft cache for bitmaps kicked out of hard cache
    private final static ConcurrentHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache =
        new ConcurrentHashMap<String, SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2);

    private final Handler purgeHandler = new Handler();

    private final Runnable purger = new Runnable() {
        public void run() {
            clearCache();
        }
    };

    /**
     * Adds this bitmap to the cache.
     * @param bitmap The newly downloaded bitmap.
     */
    private void addBitmapToCache(String url, Bitmap bitmap) {
        if (bitmap != null) {
            synchronized (sHardBitmapCache) {
                sHardBitmapCache.put(url, bitmap);
            }
        }
    }

    /**
     * @param url The URL of the image that will be retrieved from the cache.
     * @return The cached bitmap or null if it was not found.
     */
    private Bitmap getBitmapFromCache(String url) {
        // First try the hard reference cache
        synchronized (sHardBitmapCache) {
            final Bitmap bitmap = sHardBitmapCache.get(url);
            if (bitmap != null) {
                // Bitmap found in hard cache
                // Move element to first position, so that it is removed last
                sHardBitmapCache.remove(url);
                sHardBitmapCache.put(url, bitmap);
                return bitmap;
            }
        }

        // Then try the soft reference cache
        SoftReference<Bitmap> bitmapReference = sSoftBitmapCache.get(url);
        if (bitmapReference != null) {
            final Bitmap bitmap = bitmapReference.get();
            if (bitmap != null) {
                // Bitmap found in soft cache
                return bitmap;
            } else {
                // Soft reference has been Garbage Collected
                sSoftBitmapCache.remove(url);
            }
        }

        return null;
    }

    /**
     * Clears the image cache used internally to improve performance. Note that for memory
     * efficiency reasons, the cache will automatically be cleared after a certain inactivity delay.
     */
    public void clearCache() {
        sHardBitmapCache.clear();
        sSoftBitmapCache.clear();
    }

    /**
     * Allow a new delay before the automatic cache clear is done.
     */
    private void resetPurgeTimer() {
        purgeHandler.removeCallbacks(purger);
        purgeHandler.postDelayed(purger, DELAY_BEFORE_PURGE);
    }
}

0 个答案:

没有答案