| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * 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.android.camera; |
| |
| import com.android.gallery.R; |
| |
| import static com.android.camera.Util.Assert; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.Paint; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.media.AudioManager; |
| import android.os.Handler; |
| import android.util.AttributeSet; |
| import android.util.DisplayMetrics; |
| import android.view.GestureDetector; |
| import android.view.KeyEvent; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewConfiguration; |
| import android.view.GestureDetector.SimpleOnGestureListener; |
| import android.widget.Scroller; |
| |
| import com.android.camera.gallery.IImage; |
| import com.android.camera.gallery.IImageList; |
| |
| import java.util.HashMap; |
| |
| class GridViewSpecial extends View { |
| @SuppressWarnings("unused") |
| private static final String TAG = "GridViewSpecial"; |
| private static final float MAX_FLING_VELOCITY = 2500; |
| |
| public static interface Listener { |
| public void onImageClicked(int index); |
| public void onImageTapped(int index); |
| public void onLayoutComplete(boolean changed); |
| |
| /** |
| * Invoked when the <code>GridViewSpecial</code> scrolls. |
| * |
| * @param scrollPosition the position of the scroller in the range |
| * [0, 1], when 0 means on the top and 1 means on the buttom |
| */ |
| public void onScroll(float scrollPosition); |
| } |
| |
| public static interface DrawAdapter { |
| public void drawImage(Canvas canvas, IImage image, |
| Bitmap b, int xPos, int yPos, int w, int h); |
| public void drawDecoration(Canvas canvas, IImage image, |
| int xPos, int yPos, int w, int h); |
| public boolean needsDecoration(); |
| } |
| |
| public static final int INDEX_NONE = -1; |
| |
| // There are two cell size we will use. It can be set by setSizeChoice(). |
| // The mLeftEdgePadding fields is filled in onLayout(). See the comments |
| // in onLayout() for details. |
| static class LayoutSpec { |
| LayoutSpec(int w, int h, int intercellSpacing, int leftEdgePadding, |
| DisplayMetrics metrics) { |
| mCellWidth = dpToPx(w, metrics); |
| mCellHeight = dpToPx(h, metrics); |
| mCellSpacing = dpToPx(intercellSpacing, metrics); |
| mLeftEdgePadding = dpToPx(leftEdgePadding, metrics); |
| } |
| int mCellWidth, mCellHeight; |
| int mCellSpacing; |
| int mLeftEdgePadding; |
| } |
| |
| private LayoutSpec [] mCellSizeChoices; |
| |
| private void initCellSize() { |
| Activity a = (Activity) getContext(); |
| DisplayMetrics metrics = new DisplayMetrics(); |
| a.getWindowManager().getDefaultDisplay().getMetrics(metrics); |
| mCellSizeChoices = new LayoutSpec[] { |
| new LayoutSpec(67, 67, 8, 0, metrics), |
| new LayoutSpec(92, 92, 8, 0, metrics), |
| }; |
| } |
| |
| // Converts dp to pixel. |
| private static int dpToPx(int dp, DisplayMetrics metrics) { |
| return (int) (metrics.density * dp); |
| } |
| |
| // These are set in init(). |
| private final Handler mHandler = new Handler(); |
| private GestureDetector mGestureDetector; |
| private ImageBlockManager mImageBlockManager; |
| |
| // These are set in set*() functions. |
| private ImageLoader mLoader; |
| private Listener mListener = null; |
| private DrawAdapter mDrawAdapter = null; |
| private IImageList mAllImages = ImageManager.makeEmptyImageList(); |
| private int mSizeChoice = 1; // default is big cell size |
| |
| // These are set in onLayout(). |
| private LayoutSpec mSpec; |
| private int mColumns; |
| private int mMaxScrollY; |
| |
| // We can handle events only if onLayout() is completed. |
| private boolean mLayoutComplete = false; |
| |
| // Selection state |
| private int mCurrentSelection = INDEX_NONE; |
| private int mCurrentPressState = 0; |
| private static final int TAPPING_FLAG = 1; |
| private static final int CLICKING_FLAG = 2; |
| |
| // These are cached derived information. |
| private int mCount; // Cache mImageList.getCount(); |
| private int mRows; // Cache (mCount + mColumns - 1) / mColumns |
| private int mBlockHeight; // Cache mSpec.mCellSpacing + mSpec.mCellHeight |
| |
| private boolean mRunning = false; |
| private Scroller mScroller = null; |
| |
| public GridViewSpecial(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| init(context); |
| } |
| |
| private void init(Context context) { |
| setVerticalScrollBarEnabled(true); |
| initializeScrollbars(context.obtainStyledAttributes( |
| android.R.styleable.View)); |
| mGestureDetector = new GestureDetector(context, |
| new MyGestureDetector()); |
| setFocusableInTouchMode(true); |
| initCellSize(); |
| } |
| |
| private final Runnable mRedrawCallback = new Runnable() { |
| public void run() { |
| invalidate(); |
| } |
| }; |
| |
| public void setLoader(ImageLoader loader) { |
| Assert(mRunning == false); |
| mLoader = loader; |
| } |
| |
| public void setListener(Listener listener) { |
| Assert(mRunning == false); |
| mListener = listener; |
| } |
| |
| public void setDrawAdapter(DrawAdapter adapter) { |
| Assert(mRunning == false); |
| mDrawAdapter = adapter; |
| } |
| |
| public void setImageList(IImageList list) { |
| Assert(mRunning == false); |
| mAllImages = list; |
| mCount = mAllImages.getCount(); |
| } |
| |
| public void setSizeChoice(int choice) { |
| Assert(mRunning == false); |
| if (mSizeChoice == choice) return; |
| mSizeChoice = choice; |
| } |
| |
| @Override |
| public void onLayout(boolean changed, int left, int top, |
| int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| |
| if (!mRunning) { |
| return; |
| } |
| |
| mSpec = mCellSizeChoices[mSizeChoice]; |
| |
| int width = right - left; |
| |
| // The width is divided into following parts: |
| // |
| // LeftEdgePadding CellWidth (CellSpacing CellWidth)* RightEdgePadding |
| // |
| // We determine number of cells (columns) first, then the left and right |
| // padding are derived. We make left and right paddings the same size. |
| // |
| // The height is divided into following parts: |
| // |
| // CellSpacing (CellHeight CellSpacing)+ |
| |
| mColumns = 1 + (width - mSpec.mCellWidth) |
| / (mSpec.mCellWidth + mSpec.mCellSpacing); |
| |
| mSpec.mLeftEdgePadding = (width |
| - ((mColumns - 1) * mSpec.mCellSpacing) |
| - (mColumns * mSpec.mCellWidth)) / 2; |
| |
| mRows = (mCount + mColumns - 1) / mColumns; |
| mBlockHeight = mSpec.mCellSpacing + mSpec.mCellHeight; |
| mMaxScrollY = mSpec.mCellSpacing + (mRows * mBlockHeight) |
| - (bottom - top); |
| |
| // Put mScrollY in the valid range. This matters if mMaxScrollY is |
| // changed. For example, orientation changed from portrait to landscape. |
| mScrollY = Math.max(0, Math.min(mMaxScrollY, mScrollY)); |
| |
| generateOutlineBitmap(); |
| |
| if (mImageBlockManager != null) { |
| mImageBlockManager.recycle(); |
| } |
| |
| mImageBlockManager = new ImageBlockManager(mHandler, mRedrawCallback, |
| mAllImages, mLoader, mDrawAdapter, mSpec, mColumns, width, |
| mOutline[OUTLINE_EMPTY]); |
| |
| mListener.onLayoutComplete(changed); |
| |
| moveDataWindow(); |
| |
| mLayoutComplete = true; |
| } |
| |
| @Override |
| protected int computeVerticalScrollRange() { |
| return mMaxScrollY + getHeight(); |
| } |
| |
| // We cache the three outlines from NinePatch to Bitmap to speed up |
| // drawing. The cache must be updated if the cell size is changed. |
| public static final int OUTLINE_EMPTY = 0; |
| public static final int OUTLINE_PRESSED = 1; |
| public static final int OUTLINE_SELECTED = 2; |
| |
| public Bitmap mOutline[] = new Bitmap[3]; |
| |
| private void generateOutlineBitmap() { |
| int w = mSpec.mCellWidth; |
| int h = mSpec.mCellHeight; |
| |
| for (int i = 0; i < mOutline.length; i++) { |
| mOutline[i] = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888); |
| } |
| |
| Drawable cellOutline; |
| cellOutline = GridViewSpecial.this.getResources() |
| .getDrawable(android.R.drawable.gallery_thumb); |
| cellOutline.setBounds(0, 0, w, h); |
| Canvas canvas = new Canvas(); |
| |
| canvas.setBitmap(mOutline[OUTLINE_EMPTY]); |
| cellOutline.setState(EMPTY_STATE_SET); |
| cellOutline.draw(canvas); |
| |
| canvas.setBitmap(mOutline[OUTLINE_PRESSED]); |
| cellOutline.setState( |
| PRESSED_ENABLED_FOCUSED_SELECTED_WINDOW_FOCUSED_STATE_SET); |
| cellOutline.draw(canvas); |
| |
| canvas.setBitmap(mOutline[OUTLINE_SELECTED]); |
| cellOutline.setState(ENABLED_FOCUSED_SELECTED_WINDOW_FOCUSED_STATE_SET); |
| cellOutline.draw(canvas); |
| } |
| |
| private void moveDataWindow() { |
| // Calculate visible region according to scroll position. |
| int startRow = (mScrollY - mSpec.mCellSpacing) / mBlockHeight; |
| int endRow = (mScrollY + getHeight() - mSpec.mCellSpacing - 1) |
| / mBlockHeight + 1; |
| |
| // Limit startRow and endRow to the valid range. |
| // Make sure we handle the mRows == 0 case right. |
| startRow = Math.max(Math.min(startRow, mRows - 1), 0); |
| endRow = Math.max(Math.min(endRow, mRows), 0); |
| mImageBlockManager.setVisibleRows(startRow, endRow); |
| } |
| |
| // In MyGestureDetector we have to check canHandleEvent() because |
| // GestureDetector could queue events and fire them later. At that time |
| // stop() may have already been called and we can't handle the events. |
| private class MyGestureDetector extends SimpleOnGestureListener { |
| private AudioManager mAudioManager; |
| |
| @Override |
| public boolean onDown(MotionEvent e) { |
| if (!canHandleEvent()) return false; |
| if (mScroller != null && !mScroller.isFinished()) { |
| mScroller.forceFinished(true); |
| return false; |
| } |
| int index = computeSelectedIndex(e.getX(), e.getY()); |
| if (index >= 0 && index < mCount) { |
| setSelectedIndex(index); |
| } else { |
| setSelectedIndex(INDEX_NONE); |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean onFling(MotionEvent e1, MotionEvent e2, |
| float velocityX, float velocityY) { |
| if (!canHandleEvent()) return false; |
| if (velocityY > MAX_FLING_VELOCITY) { |
| velocityY = MAX_FLING_VELOCITY; |
| } else if (velocityY < -MAX_FLING_VELOCITY) { |
| velocityY = -MAX_FLING_VELOCITY; |
| } |
| |
| setSelectedIndex(INDEX_NONE); |
| mScroller = new Scroller(getContext()); |
| mScroller.fling(0, mScrollY, 0, -(int) velocityY, 0, 0, 0, |
| mMaxScrollY); |
| computeScroll(); |
| |
| return true; |
| } |
| |
| @Override |
| public void onLongPress(MotionEvent e) { |
| if (!canHandleEvent()) return; |
| performLongClick(); |
| } |
| |
| @Override |
| public boolean onScroll(MotionEvent e1, MotionEvent e2, |
| float distanceX, float distanceY) { |
| if (!canHandleEvent()) return false; |
| setSelectedIndex(INDEX_NONE); |
| scrollBy(0, (int) distanceY); |
| invalidate(); |
| return true; |
| } |
| |
| @Override |
| public boolean onSingleTapConfirmed(MotionEvent e) { |
| if (!canHandleEvent()) return false; |
| int index = computeSelectedIndex(e.getX(), e.getY()); |
| if (index >= 0 && index < mCount) { |
| // Play click sound. |
| if (mAudioManager == null) { |
| mAudioManager = (AudioManager) getContext() |
| .getSystemService(Context.AUDIO_SERVICE); |
| } |
| mAudioManager.playSoundEffect(AudioManager.FX_KEY_CLICK); |
| |
| mListener.onImageTapped(index); |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| public int getCurrentSelection() { |
| return mCurrentSelection; |
| } |
| |
| public void invalidateImage(int index) { |
| if (index != INDEX_NONE) { |
| mImageBlockManager.invalidateImage(index); |
| } |
| } |
| |
| /** |
| * |
| * @param index <code>INDEX_NONE</code> (-1) means remove selection. |
| */ |
| public void setSelectedIndex(int index) { |
| // A selection box will be shown for the image that being selected, |
| // (by finger or by the dpad center key). The selection box can be drawn |
| // in two colors. One color (yellow) is used when the the image is |
| // still being tapped or clicked (the finger is still on the touch |
| // screen or the dpad center key is not released). Another color |
| // (orange) is used after the finger leaves touch screen or the dpad |
| // center key is released. |
| |
| if (mCurrentSelection == index) { |
| return; |
| } |
| // This happens when the last picture is deleted. |
| mCurrentSelection = Math.min(index, mCount - 1); |
| |
| if (mCurrentSelection != INDEX_NONE) { |
| ensureVisible(mCurrentSelection); |
| } |
| invalidate(); |
| } |
| |
| public void scrollToImage(int index) { |
| Rect r = getRectForPosition(index); |
| scrollTo(0, r.top); |
| } |
| |
| public void scrollToVisible(int index) { |
| Rect r = getRectForPosition(index); |
| int top = getScrollY(); |
| int bottom = getScrollY() + getHeight(); |
| if (r.bottom > bottom) { |
| scrollTo(0, r.bottom - getHeight()); |
| } else if (r.top < top) { |
| scrollTo(0, r.top); |
| } |
| } |
| |
| private void ensureVisible(int pos) { |
| Rect r = getRectForPosition(pos); |
| int top = getScrollY(); |
| int bot = top + getHeight(); |
| |
| if (r.bottom > bot) { |
| mScroller = new Scroller(getContext()); |
| mScroller.startScroll(mScrollX, mScrollY, 0, |
| r.bottom - getHeight() - mScrollY, 200); |
| computeScroll(); |
| } else if (r.top < top) { |
| mScroller = new Scroller(getContext()); |
| mScroller.startScroll(mScrollX, mScrollY, 0, r.top - mScrollY, 200); |
| computeScroll(); |
| } |
| } |
| |
| public void start() { |
| // These must be set before start(). |
| Assert(mLoader != null); |
| Assert(mListener != null); |
| Assert(mDrawAdapter != null); |
| mRunning = true; |
| requestLayout(); |
| } |
| |
| // If the the underlying data is changed, for example, |
| // an image is deleted, or the size choice is changed, |
| // The following sequence is needed: |
| // |
| // mGvs.stop(); |
| // mGvs.set...(...); |
| // mGvs.set...(...); |
| // mGvs.start(); |
| public void stop() { |
| // Remove the long press callback from the queue if we are going to |
| // stop. |
| mHandler.removeCallbacks(mLongPressCallback); |
| mScroller = null; |
| if (mImageBlockManager != null) { |
| mImageBlockManager.recycle(); |
| mImageBlockManager = null; |
| } |
| mRunning = false; |
| mCurrentSelection = INDEX_NONE; |
| } |
| |
| @Override |
| public void onDraw(Canvas canvas) { |
| super.onDraw(canvas); |
| if (!canHandleEvent()) return; |
| mImageBlockManager.doDraw(canvas, getWidth(), getHeight(), mScrollY); |
| paintDecoration(canvas); |
| paintSelection(canvas); |
| moveDataWindow(); |
| } |
| |
| @Override |
| public void computeScroll() { |
| if (mScroller != null) { |
| boolean more = mScroller.computeScrollOffset(); |
| scrollTo(0, mScroller.getCurrY()); |
| if (more) { |
| invalidate(); // So we draw again |
| } else { |
| mScroller = null; |
| } |
| } else { |
| super.computeScroll(); |
| } |
| } |
| |
| // Return the rectange for the thumbnail in the given position. |
| Rect getRectForPosition(int pos) { |
| int row = pos / mColumns; |
| int col = pos - (row * mColumns); |
| |
| int left = mSpec.mLeftEdgePadding |
| + (col * (mSpec.mCellWidth + mSpec.mCellSpacing)); |
| int top = row * mBlockHeight; |
| |
| return new Rect(left, top, |
| left + mSpec.mCellWidth + mSpec.mCellSpacing, |
| top + mSpec.mCellHeight + mSpec.mCellSpacing); |
| } |
| |
| // Inverse of getRectForPosition: from screen coordinate to image position. |
| int computeSelectedIndex(float xFloat, float yFloat) { |
| int x = (int) xFloat; |
| int y = (int) yFloat; |
| |
| int spacing = mSpec.mCellSpacing; |
| int leftSpacing = mSpec.mLeftEdgePadding; |
| |
| int row = (mScrollY + y - spacing) / (mSpec.mCellHeight + spacing); |
| int col = Math.min(mColumns - 1, |
| (x - leftSpacing) / (mSpec.mCellWidth + spacing)); |
| return (row * mColumns) + col; |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent ev) { |
| if (!canHandleEvent()) { |
| return false; |
| } |
| switch (ev.getAction()) { |
| case MotionEvent.ACTION_DOWN: |
| mCurrentPressState |= TAPPING_FLAG; |
| invalidate(); |
| break; |
| case MotionEvent.ACTION_UP: |
| mCurrentPressState &= ~TAPPING_FLAG; |
| invalidate(); |
| break; |
| } |
| mGestureDetector.onTouchEvent(ev); |
| // Consume all events |
| return true; |
| } |
| |
| @Override |
| public void scrollBy(int x, int y) { |
| scrollTo(mScrollX + x, mScrollY + y); |
| } |
| |
| public void scrollTo(float scrollPosition) { |
| scrollTo(0, Math.round(scrollPosition * mMaxScrollY)); |
| } |
| |
| @Override |
| public void scrollTo(int x, int y) { |
| y = Math.max(0, Math.min(mMaxScrollY, y)); |
| if (mSpec != null) { |
| mListener.onScroll((float) mScrollY / mMaxScrollY); |
| } |
| super.scrollTo(x, y); |
| } |
| |
| private boolean canHandleEvent() { |
| return mRunning && mLayoutComplete; |
| } |
| |
| private final Runnable mLongPressCallback = new Runnable() { |
| public void run() { |
| mCurrentPressState &= ~CLICKING_FLAG; |
| showContextMenu(); |
| } |
| }; |
| |
| @Override |
| public boolean onKeyDown(int keyCode, KeyEvent event) { |
| if (!canHandleEvent()) return false; |
| int sel = mCurrentSelection; |
| if (sel != INDEX_NONE) { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_DPAD_RIGHT: |
| if (sel != mCount - 1 && (sel % mColumns < mColumns - 1)) { |
| sel += 1; |
| } |
| break; |
| case KeyEvent.KEYCODE_DPAD_LEFT: |
| if (sel > 0 && (sel % mColumns != 0)) { |
| sel -= 1; |
| } |
| break; |
| case KeyEvent.KEYCODE_DPAD_UP: |
| if (sel >= mColumns) { |
| sel -= mColumns; |
| } |
| break; |
| case KeyEvent.KEYCODE_DPAD_DOWN: |
| sel = Math.min(mCount - 1, sel + mColumns); |
| break; |
| case KeyEvent.KEYCODE_DPAD_CENTER: |
| if (event.getRepeatCount() == 0) { |
| mCurrentPressState |= CLICKING_FLAG; |
| mHandler.postDelayed(mLongPressCallback, |
| ViewConfiguration.getLongPressTimeout()); |
| } |
| break; |
| default: |
| return super.onKeyDown(keyCode, event); |
| } |
| } else { |
| switch (keyCode) { |
| case KeyEvent.KEYCODE_DPAD_RIGHT: |
| case KeyEvent.KEYCODE_DPAD_LEFT: |
| case KeyEvent.KEYCODE_DPAD_UP: |
| case KeyEvent.KEYCODE_DPAD_DOWN: |
| int startRow = |
| (mScrollY - mSpec.mCellSpacing) / mBlockHeight; |
| int topPos = startRow * mColumns; |
| Rect r = getRectForPosition(topPos); |
| if (r.top < getScrollY()) { |
| topPos += mColumns; |
| } |
| topPos = Math.min(mCount - 1, topPos); |
| sel = topPos; |
| break; |
| default: |
| return super.onKeyDown(keyCode, event); |
| } |
| } |
| setSelectedIndex(sel); |
| return true; |
| } |
| |
| @Override |
| public boolean onKeyUp(int keyCode, KeyEvent event) { |
| if (!canHandleEvent()) return false; |
| |
| if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) { |
| mCurrentPressState &= ~CLICKING_FLAG; |
| invalidate(); |
| |
| // The keyUp doesn't get called when the longpress menu comes up. We |
| // only get here when the user lets go of the center key before the |
| // longpress menu comes up. |
| mHandler.removeCallbacks(mLongPressCallback); |
| |
| // open the photo |
| mListener.onImageClicked(mCurrentSelection); |
| return true; |
| } |
| return super.onKeyUp(keyCode, event); |
| } |
| |
| private void paintDecoration(Canvas canvas) { |
| if (!mDrawAdapter.needsDecoration()) return; |
| |
| // Calculate visible region according to scroll position. |
| int startRow = (mScrollY - mSpec.mCellSpacing) / mBlockHeight; |
| int endRow = (mScrollY + getHeight() - mSpec.mCellSpacing - 1) |
| / mBlockHeight + 1; |
| |
| // Limit startRow and endRow to the valid range. |
| // Make sure we handle the mRows == 0 case right. |
| startRow = Math.max(Math.min(startRow, mRows - 1), 0); |
| endRow = Math.max(Math.min(endRow, mRows), 0); |
| |
| int startIndex = startRow * mColumns; |
| int endIndex = Math.min(endRow * mColumns, mCount); |
| |
| int xPos = mSpec.mLeftEdgePadding; |
| int yPos = mSpec.mCellSpacing + startRow * mBlockHeight; |
| int off = 0; |
| for (int i = startIndex; i < endIndex; i++) { |
| IImage image = mAllImages.getImageAt(i); |
| |
| mDrawAdapter.drawDecoration(canvas, image, xPos, yPos, |
| mSpec.mCellWidth, mSpec.mCellHeight); |
| |
| // Calculate next position |
| off += 1; |
| if (off == mColumns) { |
| xPos = mSpec.mLeftEdgePadding; |
| yPos += mBlockHeight; |
| off = 0; |
| } else { |
| xPos += mSpec.mCellWidth + mSpec.mCellSpacing; |
| } |
| } |
| } |
| |
| private void paintSelection(Canvas canvas) { |
| if (mCurrentSelection == INDEX_NONE) return; |
| |
| int row = mCurrentSelection / mColumns; |
| int col = mCurrentSelection - (row * mColumns); |
| |
| int spacing = mSpec.mCellSpacing; |
| int leftSpacing = mSpec.mLeftEdgePadding; |
| int xPos = leftSpacing + (col * (mSpec.mCellWidth + spacing)); |
| int yTop = spacing + (row * mBlockHeight); |
| |
| int type = OUTLINE_SELECTED; |
| if (mCurrentPressState != 0) { |
| type = OUTLINE_PRESSED; |
| } |
| canvas.drawBitmap(mOutline[type], xPos, yTop, null); |
| } |
| } |
| |
| class ImageBlockManager { |
| @SuppressWarnings("unused") |
| private static final String TAG = "ImageBlockManager"; |
| |
| // Number of rows we want to cache. |
| // Assume there are 6 rows per page, this caches 5 pages. |
| private static final int CACHE_ROWS = 30; |
| |
| // mCache maps from row number to the ImageBlock. |
| private final HashMap<Integer, ImageBlock> mCache; |
| |
| // These are parameters set in the constructor. |
| private final Handler mHandler; |
| private final Runnable mRedrawCallback; // Called after a row is loaded, |
| // so GridViewSpecial can draw |
| // again using the new images. |
| private final IImageList mImageList; |
| private final ImageLoader mLoader; |
| private final GridViewSpecial.DrawAdapter mDrawAdapter; |
| private final GridViewSpecial.LayoutSpec mSpec; |
| private final int mColumns; // Columns per row. |
| private final int mBlockWidth; // The width of an ImageBlock. |
| private final Bitmap mOutline; // The outline bitmap put on top of each |
| // image. |
| private final int mCount; // Cache mImageList.getCount(). |
| private final int mRows; // Cache (mCount + mColumns - 1) / mColumns |
| private final int mBlockHeight; // The height of an ImageBlock. |
| |
| // Visible row range: [mStartRow, mEndRow). Set by setVisibleRows(). |
| private int mStartRow = 0; |
| private int mEndRow = 0; |
| |
| ImageBlockManager(Handler handler, Runnable redrawCallback, |
| IImageList imageList, ImageLoader loader, |
| GridViewSpecial.DrawAdapter adapter, |
| GridViewSpecial.LayoutSpec spec, |
| int columns, int blockWidth, Bitmap outline) { |
| mHandler = handler; |
| mRedrawCallback = redrawCallback; |
| mImageList = imageList; |
| mLoader = loader; |
| mDrawAdapter = adapter; |
| mSpec = spec; |
| mColumns = columns; |
| mBlockWidth = blockWidth; |
| mOutline = outline; |
| mBlockHeight = mSpec.mCellSpacing + mSpec.mCellHeight; |
| mCount = imageList.getCount(); |
| mRows = (mCount + mColumns - 1) / mColumns; |
| mCache = new HashMap<Integer, ImageBlock>(); |
| mPendingRequest = 0; |
| initGraphics(); |
| } |
| |
| // Set the window of visible rows. Once set we will start to load them as |
| // soon as possible (if they are not already in cache). |
| public void setVisibleRows(int startRow, int endRow) { |
| if (startRow != mStartRow || endRow != mEndRow) { |
| mStartRow = startRow; |
| mEndRow = endRow; |
| startLoading(); |
| } |
| } |
| |
| int mPendingRequest; // Number of pending requests (sent to ImageLoader). |
| // We want to keep enough requests in ImageLoader's queue, but not too |
| // many. |
| static final int REQUESTS_LOW = 3; |
| static final int REQUESTS_HIGH = 6; |
| |
| // After clear requests currently in queue, start loading the thumbnails. |
| // We need to clear the queue first because the proper order of loading |
| // may have changed (because the visible region changed, or some images |
| // have been invalidated). |
| private void startLoading() { |
| clearLoaderQueue(); |
| continueLoading(); |
| } |
| |
| private void clearLoaderQueue() { |
| int[] tags = mLoader.clearQueue(); |
| for (int pos : tags) { |
| int row = pos / mColumns; |
| int col = pos - row * mColumns; |
| ImageBlock blk = mCache.get(row); |
| Assert(blk != null); // We won't reuse the block if it has pending |
| // requests. See getEmptyBlock(). |
| blk.cancelRequest(col); |
| } |
| } |
| |
| // Scan the cache and send requests to ImageLoader if needed. |
| private void continueLoading() { |
| // Check if we still have enough requests in the queue. |
| if (mPendingRequest >= REQUESTS_LOW) return; |
| |
| // Scan the visible rows. |
| for (int i = mStartRow; i < mEndRow; i++) { |
| if (scanOne(i)) return; |
| } |
| |
| int range = (CACHE_ROWS - (mEndRow - mStartRow)) / 2; |
| // Scan other rows. |
| // d is the distance between the row and visible region. |
| for (int d = 1; d <= range; d++) { |
| int after = mEndRow - 1 + d; |
| int before = mStartRow - d; |
| if (after >= mRows && before < 0) { |
| break; // Nothing more the scan. |
| } |
| if (after < mRows && scanOne(after)) return; |
| if (before >= 0 && scanOne(before)) return; |
| } |
| } |
| |
| // Returns true if we can stop scanning. |
| private boolean scanOne(int i) { |
| mPendingRequest += tryToLoad(i); |
| return mPendingRequest >= REQUESTS_HIGH; |
| } |
| |
| // Returns number of requests we issued for this row. |
| private int tryToLoad(int row) { |
| Assert(row >= 0 && row < mRows); |
| ImageBlock blk = mCache.get(row); |
| if (blk == null) { |
| // Find an empty block |
| blk = getEmptyBlock(); |
| blk.setRow(row); |
| blk.invalidate(); |
| mCache.put(row, blk); |
| } |
| return blk.loadImages(); |
| } |
| |
| // Get an empty block for the cache. |
| private ImageBlock getEmptyBlock() { |
| // See if we can allocate a new block. |
| if (mCache.size() < CACHE_ROWS) { |
| return new ImageBlock(); |
| } |
| // Reclaim the old block with largest distance from the visible region. |
| int bestDistance = -1; |
| int bestIndex = -1; |
| for (int index : mCache.keySet()) { |
| // Make sure we don't reclaim a block which still has pending |
| // request. |
| if (mCache.get(index).hasPendingRequests()) { |
| continue; |
| } |
| int dist = 0; |
| if (index >= mEndRow) { |
| dist = index - mEndRow + 1; |
| } else if (index < mStartRow) { |
| dist = mStartRow - index; |
| } else { |
| // Inside the visible region. |
| continue; |
| } |
| if (dist > bestDistance) { |
| bestDistance = dist; |
| bestIndex = index; |
| } |
| } |
| return mCache.remove(bestIndex); |
| } |
| |
| public void invalidateImage(int index) { |
| int row = index / mColumns; |
| int col = index - (row * mColumns); |
| ImageBlock blk = mCache.get(row); |
| if (blk == null) return; |
| if ((blk.mCompletedMask & (1 << col)) != 0) { |
| blk.mCompletedMask &= ~(1 << col); |
| } |
| startLoading(); |
| } |
| |
| // After calling recycle(), the instance should not be used anymore. |
| public void recycle() { |
| for (ImageBlock blk : mCache.values()) { |
| blk.recycle(); |
| } |
| mCache.clear(); |
| mEmptyBitmap.recycle(); |
| } |
| |
| // Draw the images to the given canvas. |
| public void doDraw(Canvas canvas, int thisWidth, int thisHeight, |
| int scrollPos) { |
| final int height = mBlockHeight; |
| |
| // Note that currentBlock could be negative. |
| int currentBlock = (scrollPos < 0) |
| ? ((scrollPos - height + 1) / height) |
| : (scrollPos / height); |
| |
| while (true) { |
| final int yPos = currentBlock * height; |
| if (yPos >= scrollPos + thisHeight) { |
| break; |
| } |
| |
| ImageBlock blk = mCache.get(currentBlock); |
| if (blk != null) { |
| blk.doDraw(canvas, 0, yPos); |
| } else { |
| drawEmptyBlock(canvas, 0, yPos, currentBlock); |
| } |
| |
| currentBlock += 1; |
| } |
| } |
| |
| // Return number of columns in the given row. (This could be less than |
| // mColumns for the last row). |
| private int numColumns(int row) { |
| return Math.min(mColumns, mCount - row * mColumns); |
| } |
| |
| // Draw a block which has not been loaded. |
| private void drawEmptyBlock(Canvas canvas, int xPos, int yPos, int row) { |
| // Draw the background. |
| canvas.drawRect(xPos, yPos, xPos + mBlockWidth, yPos + mBlockHeight, |
| mBackgroundPaint); |
| |
| // Draw the empty images. |
| int x = xPos + mSpec.mLeftEdgePadding; |
| int y = yPos + mSpec.mCellSpacing; |
| int cols = numColumns(row); |
| |
| for (int i = 0; i < cols; i++) { |
| canvas.drawBitmap(mEmptyBitmap, x, y, null); |
| x += (mSpec.mCellWidth + mSpec.mCellSpacing); |
| } |
| } |
| |
| // mEmptyBitmap is what we draw if we the wanted block hasn't been loaded. |
| // (If the user scrolls too fast). It is a gray image with normal outline. |
| // mBackgroundPaint is used to draw the (black) background outside |
| // mEmptyBitmap. |
| Paint mBackgroundPaint; |
| private Bitmap mEmptyBitmap; |
| |
| private void initGraphics() { |
| mBackgroundPaint = new Paint(); |
| mBackgroundPaint.setStyle(Paint.Style.FILL); |
| mBackgroundPaint.setColor(0xFF000000); // black |
| mEmptyBitmap = Bitmap.createBitmap(mSpec.mCellWidth, mSpec.mCellHeight, |
| Bitmap.Config.RGB_565); |
| Canvas canvas = new Canvas(mEmptyBitmap); |
| canvas.drawRGB(0xDD, 0xDD, 0xDD); |
| canvas.drawBitmap(mOutline, 0, 0, null); |
| } |
| |
| // ImageBlock stores bitmap for one row. The loaded thumbnail images are |
| // drawn to mBitmap. mBitmap is later used in onDraw() of GridViewSpecial. |
| private class ImageBlock { |
| private Bitmap mBitmap; |
| private final Canvas mCanvas; |
| |
| // Columns which have been requested to the loader |
| private int mRequestedMask; |
| |
| // Columns which have been completed from the loader |
| private int mCompletedMask; |
| |
| // The row number this block represents. |
| private int mRow; |
| |
| public ImageBlock() { |
| mBitmap = Bitmap.createBitmap(mBlockWidth, mBlockHeight, |
| Bitmap.Config.RGB_565); |
| mCanvas = new Canvas(mBitmap); |
| mRow = -1; |
| } |
| |
| public void setRow(int row) { |
| mRow = row; |
| } |
| |
| public void invalidate() { |
| // We do not change mRequestedMask or do cancelAllRequests() |
| // because the data coming from pending requests are valid. (We only |
| // invalidate data which has been drawn to the bitmap). |
| mCompletedMask = 0; |
| } |
| |
| // After recycle, the ImageBlock instance should not be accessed. |
| public void recycle() { |
| cancelAllRequests(); |
| mBitmap.recycle(); |
| mBitmap = null; |
| } |
| |
| private boolean isVisible() { |
| return mRow >= mStartRow && mRow < mEndRow; |
| } |
| |
| // Returns number of requests submitted to ImageLoader. |
| public int loadImages() { |
| Assert(mRow != -1); |
| |
| int columns = numColumns(mRow); |
| |
| // Calculate what we need. |
| int needMask = ((1 << columns) - 1) |
| & ~(mCompletedMask | mRequestedMask); |
| |
| if (needMask == 0) { |
| return 0; |
| } |
| |
| int retVal = 0; |
| int base = mRow * mColumns; |
| |
| for (int col = 0; col < columns; col++) { |
| if ((needMask & (1 << col)) == 0) { |
| continue; |
| } |
| |
| int pos = base + col; |
| |
| final IImage image = mImageList.getImageAt(pos); |
| if (image != null) { |
| // This callback is passed to ImageLoader. It will invoke |
| // loadImageDone() in the main thread. We limit the callback |
| // thread to be in this very short function. All other |
| // processing is done in the main thread. |
| final int colFinal = col; |
| ImageLoader.LoadedCallback cb = |
| new ImageLoader.LoadedCallback() { |
| public void run(final Bitmap b) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| loadImageDone(image, b, |
| colFinal); |
| } |
| }); |
| } |
| }; |
| // Load Image |
| mLoader.getBitmap(image, cb, pos); |
| mRequestedMask |= (1 << col); |
| retVal += 1; |
| } |
| } |
| |
| return retVal; |
| } |
| |
| // Whether this block has pending requests. |
| public boolean hasPendingRequests() { |
| return mRequestedMask != 0; |
| } |
| |
| // Called when an image is loaded. |
| private void loadImageDone(IImage image, Bitmap b, |
| int col) { |
| if (mBitmap == null) return; // This block has been recycled. |
| |
| int spacing = mSpec.mCellSpacing; |
| int leftSpacing = mSpec.mLeftEdgePadding; |
| final int yPos = spacing; |
| final int xPos = leftSpacing |
| + (col * (mSpec.mCellWidth + spacing)); |
| |
| drawBitmap(image, b, xPos, yPos); |
| |
| if (b != null) { |
| b.recycle(); |
| } |
| |
| int mask = (1 << col); |
| Assert((mCompletedMask & mask) == 0); |
| Assert((mRequestedMask & mask) != 0); |
| mRequestedMask &= ~mask; |
| mCompletedMask |= mask; |
| mPendingRequest--; |
| |
| if (isVisible()) { |
| mRedrawCallback.run(); |
| } |
| |
| // Kick start next block loading. |
| continueLoading(); |
| } |
| |
| // Draw the loaded bitmap to the block bitmap. |
| private void drawBitmap( |
| IImage image, Bitmap b, int xPos, int yPos) { |
| mDrawAdapter.drawImage(mCanvas, image, b, xPos, yPos, |
| mSpec.mCellWidth, mSpec.mCellHeight); |
| mCanvas.drawBitmap(mOutline, xPos, yPos, null); |
| } |
| |
| // Draw the block bitmap to the specified canvas. |
| public void doDraw(Canvas canvas, int xPos, int yPos) { |
| int cols = numColumns(mRow); |
| |
| if (cols == mColumns) { |
| canvas.drawBitmap(mBitmap, xPos, yPos, null); |
| } else { |
| |
| // This must be the last row -- we draw only part of the block. |
| // Draw the background. |
| canvas.drawRect(xPos, yPos, xPos + mBlockWidth, |
| yPos + mBlockHeight, mBackgroundPaint); |
| // Draw part of the block. |
| int w = mSpec.mLeftEdgePadding |
| + cols * (mSpec.mCellWidth + mSpec.mCellSpacing); |
| Rect srcRect = new Rect(0, 0, w, mBlockHeight); |
| Rect dstRect = new Rect(srcRect); |
| dstRect.offset(xPos, yPos); |
| canvas.drawBitmap(mBitmap, srcRect, dstRect, null); |
| } |
| |
| // Draw the part which has not been loaded. |
| int isEmpty = ((1 << cols) - 1) & ~mCompletedMask; |
| |
| if (isEmpty != 0) { |
| int x = xPos + mSpec.mLeftEdgePadding; |
| int y = yPos + mSpec.mCellSpacing; |
| |
| for (int i = 0; i < cols; i++) { |
| if ((isEmpty & (1 << i)) != 0) { |
| canvas.drawBitmap(mEmptyBitmap, x, y, null); |
| } |
| x += (mSpec.mCellWidth + mSpec.mCellSpacing); |
| } |
| } |
| } |
| |
| // Mark a request as cancelled. The request has already been removed |
| // from the queue of ImageLoader, so we only need to mark the fact. |
| public void cancelRequest(int col) { |
| int mask = (1 << col); |
| Assert((mRequestedMask & mask) != 0); |
| mRequestedMask &= ~mask; |
| mPendingRequest--; |
| } |
| |
| // Try to cancel all pending requests for this block. After this |
| // completes there could still be requests not cancelled (because it is |
| // already in progress). We deal with that situation by setting mBitmap |
| // to null in recycle() and check this in loadImageDone(). |
| private void cancelAllRequests() { |
| for (int i = 0; i < mColumns; i++) { |
| int mask = (1 << i); |
| if ((mRequestedMask & mask) != 0) { |
| int pos = (mRow * mColumns) + i; |
| if (mLoader.cancel(mImageList.getImageAt(pos))) { |
| mRequestedMask &= ~mask; |
| mPendingRequest--; |
| } |
| } |
| } |
| } |
| } |
| } |
