Java tutorial
/* * Copyright (C) 2013 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.photos.views; import android.content.Context; import android.content.res.TypedArray; import android.database.DataSetObserver; import android.graphics.Canvas; import android.support.v4.view.MotionEventCompat; import android.support.v4.view.VelocityTrackerCompat; import android.support.v4.view.ViewCompat; import android.support.v4.widget.EdgeEffectCompat; import android.util.AttributeSet; import android.util.Log; import android.util.SparseArray; import android.view.MotionEvent; import android.view.VelocityTracker; import android.view.View; import android.view.ViewConfiguration; import android.view.ViewGroup; import android.widget.ListAdapter; import android.widget.OverScroller; import java.util.ArrayList; public class GalleryThumbnailView extends ViewGroup { public interface GalleryThumbnailAdapter extends ListAdapter { /** * @param position Position to get the intrinsic aspect ratio for * @return width / height */ float getIntrinsicAspectRatio(int position); } private static final String TAG = "GalleryThumbnailView"; private static final float ASPECT_RATIO = (float) Math.sqrt(1.5f); private static final int LAND_UNITS = 2; private static final int PORT_UNITS = 3; private GalleryThumbnailAdapter mAdapter; private final RecycleBin mRecycler = new RecycleBin(); private final AdapterDataSetObserver mObserver = new AdapterDataSetObserver(); private boolean mDataChanged; private int mOldItemCount; private int mItemCount; private boolean mHasStableIds; private int mFirstPosition; private boolean mPopulating; private boolean mInLayout; private int mTouchSlop; private int mMaximumVelocity; private int mFlingVelocity; private float mLastTouchX; private float mTouchRemainderX; private int mActivePointerId; private static final int TOUCH_MODE_IDLE = 0; private static final int TOUCH_MODE_DRAGGING = 1; private static final int TOUCH_MODE_FLINGING = 2; private int mTouchMode; private final VelocityTracker mVelocityTracker = VelocityTracker.obtain(); private final OverScroller mScroller; private final EdgeEffectCompat mLeftEdge; private final EdgeEffectCompat mRightEdge; private int mLargeColumnWidth; private int mSmallColumnWidth; private int mLargeColumnUnitCount = 8; private int mSmallColumnUnitCount = 10; public GalleryThumbnailView(Context context) { this(context, null); } public GalleryThumbnailView(Context context, AttributeSet attrs) { this(context, attrs, 0); } public GalleryThumbnailView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); final ViewConfiguration vc = ViewConfiguration.get(context); mTouchSlop = vc.getScaledTouchSlop(); mMaximumVelocity = vc.getScaledMaximumFlingVelocity(); mFlingVelocity = vc.getScaledMinimumFlingVelocity(); mScroller = new OverScroller(context); mLeftEdge = new EdgeEffectCompat(context); mRightEdge = new EdgeEffectCompat(context); setWillNotDraw(false); setClipToPadding(false); } @Override public void requestLayout() { if (!mPopulating) { super.requestLayout(); } } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int widthMode = MeasureSpec.getMode(widthMeasureSpec); int heightMode = MeasureSpec.getMode(heightMeasureSpec); int widthSize = MeasureSpec.getSize(widthMeasureSpec); int heightSize = MeasureSpec.getSize(heightMeasureSpec); if (widthMode != MeasureSpec.EXACTLY) { Log.e(TAG, "onMeasure: must have an exact width or match_parent! " + "Using fallback spec of EXACTLY " + widthSize); } if (heightMode != MeasureSpec.EXACTLY) { Log.e(TAG, "onMeasure: must have an exact height or match_parent! " + "Using fallback spec of EXACTLY " + heightSize); } setMeasuredDimension(widthSize, heightSize); float portSpaces = mLargeColumnUnitCount / PORT_UNITS; float height = getMeasuredHeight() / portSpaces; mLargeColumnWidth = (int) (height / ASPECT_RATIO); portSpaces++; height = getMeasuredHeight() / portSpaces; mSmallColumnWidth = (int) (height / ASPECT_RATIO); } @Override protected void onLayout(boolean changed, int l, int t, int r, int b) { mInLayout = true; populate(); mInLayout = false; final int width = r - l; final int height = b - t; mLeftEdge.setSize(width, height); mRightEdge.setSize(width, height); } private void populate() { if (getWidth() == 0 || getHeight() == 0) { return; } // TODO: Handle size changing // final int colCount = mColCount; // if (mItemTops == null || mItemTops.length != colCount) { // mItemTops = new int[colCount]; // mItemBottoms = new int[colCount]; // final int top = getPaddingTop(); // final int offset = top + Math.min(mRestoreOffset, 0); // Arrays.fill(mItemTops, offset); // Arrays.fill(mItemBottoms, offset); // mLayoutRecords.clear(); // if (mInLayout) { // removeAllViewsInLayout(); // } else { // removeAllViews(); // } // mRestoreOffset = 0; // } mPopulating = true; layoutChildren(mDataChanged); fillRight(mFirstPosition + getChildCount(), 0); fillLeft(mFirstPosition - 1, 0); mPopulating = false; mDataChanged = false; } final void layoutChildren(boolean queryAdapter) { // TODO // final int childCount = getChildCount(); // for (int i = 0; i < childCount; i++) { // View child = getChildAt(i); // // if (child.isLayoutRequested()) { // final int widthSpec = MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(), MeasureSpec.EXACTLY); // final int heightSpec = MeasureSpec.makeMeasureSpec(child.getMeasuredHeight(), MeasureSpec.EXACTLY); // child.measure(widthSpec, heightSpec); // child.layout(child.getLeft(), child.getTop(), child.getRight(), child.getBottom()); // } // // int childTop = mItemBottoms[col] > Integer.MIN_VALUE ? // mItemBottoms[col] + mItemMargin : child.getTop(); // if (span > 1) { // int lowest = childTop; // for (int j = col + 1; j < col + span; j++) { // final int bottom = mItemBottoms[j] + mItemMargin; // if (bottom > lowest) { // lowest = bottom; // } // } // childTop = lowest; // } // final int childHeight = child.getMeasuredHeight(); // final int childBottom = childTop + childHeight; // final int childLeft = paddingLeft + col * (colWidth + itemMargin); // final int childRight = childLeft + child.getMeasuredWidth(); // child.layout(childLeft, childTop, childRight, childBottom); // } } /** * Obtain the view and add it to our list of children. The view can be made * fresh, converted from an unused view, or used as is if it was in the * recycle bin. * * @param startPosition Logical position in the list to start from * @param x Left or right edge of the view to add * @param forward If true, align left edge to x and increase position. * If false, align right edge to x and decrease position. * @return Number of views added */ private int makeAndAddColumn(int startPosition, int x, boolean forward) { int columnWidth = mLargeColumnWidth; int addViews = 0; for (int remaining = mLargeColumnUnitCount, i = 0; remaining > 0 && startPosition + i >= 0 && startPosition + i < mItemCount; i += forward ? 1 : -1, addViews++) { if (mAdapter.getIntrinsicAspectRatio(startPosition + i) >= 1f) { // landscape remaining -= LAND_UNITS; } else { // portrait remaining -= PORT_UNITS; if (remaining < 0) { remaining += (mSmallColumnUnitCount - mLargeColumnUnitCount); columnWidth = mSmallColumnWidth; } } } int nextTop = 0; for (int i = 0; i < addViews; i++) { int position = startPosition + (forward ? i : -i); View child = obtainView(position, null); if (child.getParent() != this) { if (mInLayout) { addViewInLayout(child, forward ? -1 : 0, child.getLayoutParams()); } else { addView(child, forward ? -1 : 0); } } int heightSize = (int) (.5f + (mAdapter.getIntrinsicAspectRatio(position) >= 1f ? columnWidth / ASPECT_RATIO : columnWidth * ASPECT_RATIO)); int heightSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY); int widthSpec = MeasureSpec.makeMeasureSpec(columnWidth, MeasureSpec.EXACTLY); child.measure(widthSpec, heightSpec); int childLeft = forward ? x : x - columnWidth; child.layout(childLeft, nextTop, childLeft + columnWidth, nextTop + heightSize); nextTop += heightSize; } return addViews; } @Override public boolean onInterceptTouchEvent(MotionEvent ev) { mVelocityTracker.addMovement(ev); final int action = ev.getAction() & MotionEventCompat.ACTION_MASK; switch (action) { case MotionEvent.ACTION_DOWN: mVelocityTracker.clear(); mScroller.abortAnimation(); mLastTouchX = ev.getX(); mActivePointerId = MotionEventCompat.getPointerId(ev, 0); mTouchRemainderX = 0; if (mTouchMode == TOUCH_MODE_FLINGING) { // Catch! mTouchMode = TOUCH_MODE_DRAGGING; return true; } break; case MotionEvent.ACTION_MOVE: { final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId); if (index < 0) { Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " + mActivePointerId + " - did StaggeredGridView receive an inconsistent " + "event stream?"); return false; } final float x = MotionEventCompat.getX(ev, index); final float dx = x - mLastTouchX + mTouchRemainderX; final int deltaY = (int) dx; mTouchRemainderX = dx - deltaY; if (Math.abs(dx) > mTouchSlop) { mTouchMode = TOUCH_MODE_DRAGGING; return true; } } } return false; } @Override public boolean onTouchEvent(MotionEvent ev) { mVelocityTracker.addMovement(ev); final int action = ev.getAction() & MotionEventCompat.ACTION_MASK; switch (action) { case MotionEvent.ACTION_DOWN: mVelocityTracker.clear(); mScroller.abortAnimation(); mLastTouchX = ev.getX(); mActivePointerId = MotionEventCompat.getPointerId(ev, 0); mTouchRemainderX = 0; break; case MotionEvent.ACTION_MOVE: { final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId); if (index < 0) { Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " + mActivePointerId + " - did StaggeredGridView receive an inconsistent " + "event stream?"); return false; } final float x = MotionEventCompat.getX(ev, index); final float dx = x - mLastTouchX + mTouchRemainderX; final int deltaX = (int) dx; mTouchRemainderX = dx - deltaX; if (Math.abs(dx) > mTouchSlop) { mTouchMode = TOUCH_MODE_DRAGGING; } if (mTouchMode == TOUCH_MODE_DRAGGING) { mLastTouchX = x; if (!trackMotionScroll(deltaX, true)) { // Break fling velocity if we impacted an edge. mVelocityTracker.clear(); } } } break; case MotionEvent.ACTION_CANCEL: mTouchMode = TOUCH_MODE_IDLE; break; case MotionEvent.ACTION_UP: { mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); final float velocity = VelocityTrackerCompat.getXVelocity(mVelocityTracker, mActivePointerId); if (Math.abs(velocity) > mFlingVelocity) { // TODO mTouchMode = TOUCH_MODE_FLINGING; mScroller.fling(0, 0, (int) velocity, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0); mLastTouchX = 0; ViewCompat.postInvalidateOnAnimation(this); } else { mTouchMode = TOUCH_MODE_IDLE; } } break; } return true; } /** * * @param deltaX Pixels that content should move by * @return true if the movement completed, false if it was stopped prematurely. */ private boolean trackMotionScroll(int deltaX, boolean allowOverScroll) { final boolean contentFits = contentFits(); final int allowOverhang = Math.abs(deltaX); final int overScrolledBy; final int movedBy; if (!contentFits) { final int overhang; final boolean up; mPopulating = true; if (deltaX > 0) { overhang = fillLeft(mFirstPosition - 1, allowOverhang); up = true; } else { overhang = fillRight(mFirstPosition + getChildCount(), allowOverhang); up = false; } movedBy = Math.min(overhang, allowOverhang); offsetChildren(up ? movedBy : -movedBy); recycleOffscreenViews(); mPopulating = false; overScrolledBy = allowOverhang - overhang; } else { overScrolledBy = allowOverhang; movedBy = 0; } if (allowOverScroll) { final int overScrollMode = ViewCompat.getOverScrollMode(this); if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS || (overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS && !contentFits)) { if (overScrolledBy > 0) { EdgeEffectCompat edge = deltaX > 0 ? mLeftEdge : mRightEdge; edge.onPull((float) Math.abs(deltaX) / getWidth()); ViewCompat.postInvalidateOnAnimation(this); } } } return deltaX == 0 || movedBy != 0; } /** * Important: this method will leave offscreen views attached if they * are required to maintain the invariant that child view with index i * is always the view corresponding to position mFirstPosition + i. */ private void recycleOffscreenViews() { final int height = getHeight(); final int clearAbove = 0; final int clearBelow = height; for (int i = getChildCount() - 1; i >= 0; i--) { final View child = getChildAt(i); if (child.getTop() <= clearBelow) { // There may be other offscreen views, but we need to maintain // the invariant documented above. break; } if (mInLayout) { removeViewsInLayout(i, 1); } else { removeViewAt(i); } mRecycler.addScrap(child); } while (getChildCount() > 0) { final View child = getChildAt(0); if (child.getBottom() >= clearAbove) { // There may be other offscreen views, but we need to maintain // the invariant documented above. break; } if (mInLayout) { removeViewsInLayout(0, 1); } else { removeViewAt(0); } mRecycler.addScrap(child); mFirstPosition++; } } final void offsetChildren(int offset) { final int childCount = getChildCount(); for (int i = 0; i < childCount; i++) { final View child = getChildAt(i); child.layout(child.getLeft() + offset, child.getTop(), child.getRight() + offset, child.getBottom()); } } private boolean contentFits() { final int childCount = getChildCount(); if (childCount == 0) return true; if (childCount != mItemCount) return false; return getChildAt(0).getLeft() >= getPaddingLeft() && getChildAt(childCount - 1).getRight() <= getWidth() - getPaddingRight(); } private void recycleAllViews() { for (int i = 0; i < getChildCount(); i++) { mRecycler.addScrap(getChildAt(i)); } if (mInLayout) { removeAllViewsInLayout(); } else { removeAllViews(); } } private int fillRight(int pos, int overhang) { int end = (getRight() - getLeft()) + overhang; int nextLeft = getChildCount() == 0 ? 0 : getChildAt(getChildCount() - 1).getRight(); while (nextLeft < end && pos < mItemCount) { pos += makeAndAddColumn(pos, nextLeft, true); nextLeft = getChildAt(getChildCount() - 1).getRight(); } final int gridRight = getWidth() - getPaddingRight(); return getChildAt(getChildCount() - 1).getRight() - gridRight; } private int fillLeft(int pos, int overhang) { int end = getPaddingLeft() - overhang; int nextRight = getChildAt(0).getLeft(); while (nextRight > end && pos >= 0) { pos -= makeAndAddColumn(pos, nextRight, false); nextRight = getChildAt(0).getLeft(); } mFirstPosition = pos + 1; return getPaddingLeft() - getChildAt(0).getLeft(); } @Override public void computeScroll() { if (mScroller.computeScrollOffset()) { final int x = mScroller.getCurrX(); final int dx = (int) (x - mLastTouchX); mLastTouchX = x; final boolean stopped = !trackMotionScroll(dx, false); if (!stopped && !mScroller.isFinished()) { ViewCompat.postInvalidateOnAnimation(this); } else { if (stopped) { final int overScrollMode = ViewCompat.getOverScrollMode(this); if (overScrollMode != ViewCompat.OVER_SCROLL_NEVER) { final EdgeEffectCompat edge; if (dx > 0) { edge = mLeftEdge; } else { edge = mRightEdge; } edge.onAbsorb(Math.abs((int) mScroller.getCurrVelocity())); ViewCompat.postInvalidateOnAnimation(this); } mScroller.abortAnimation(); } mTouchMode = TOUCH_MODE_IDLE; } } } @Override public void draw(Canvas canvas) { super.draw(canvas); if (!mLeftEdge.isFinished()) { final int restoreCount = canvas.save(); final int height = getHeight() - getPaddingTop() - getPaddingBottom(); canvas.rotate(270); canvas.translate(-height + getPaddingTop(), 0); mLeftEdge.setSize(height, getWidth()); if (mLeftEdge.draw(canvas)) { postInvalidateOnAnimation(); } canvas.restoreToCount(restoreCount); } if (!mRightEdge.isFinished()) { final int restoreCount = canvas.save(); final int width = getWidth(); final int height = getHeight() - getPaddingTop() - getPaddingBottom(); canvas.rotate(90); canvas.translate(-getPaddingTop(), width); mRightEdge.setSize(height, width); if (mRightEdge.draw(canvas)) { postInvalidateOnAnimation(); } canvas.restoreToCount(restoreCount); } } /** * Obtain a populated view from the adapter. If optScrap is non-null and is not * reused it will be placed in the recycle bin. * * @param position position to get view for * @param optScrap Optional scrap view; will be reused if possible * @return A new view, a recycled view from mRecycler, or optScrap */ private final View obtainView(int position, View optScrap) { View view = mRecycler.getTransientStateView(position); if (view != null) { return view; } // Reuse optScrap if it's of the right type (and not null) final int optType = optScrap != null ? ((LayoutParams) optScrap.getLayoutParams()).viewType : -1; final int positionViewType = mAdapter.getItemViewType(position); final View scrap = optType == positionViewType ? optScrap : mRecycler.getScrapView(positionViewType); view = mAdapter.getView(position, scrap, this); if (view != scrap && scrap != null) { // The adapter didn't use it; put it back. mRecycler.addScrap(scrap); } ViewGroup.LayoutParams lp = view.getLayoutParams(); if (view.getParent() != this) { if (lp == null) { lp = generateDefaultLayoutParams(); } else if (!checkLayoutParams(lp)) { lp = generateLayoutParams(lp); } view.setLayoutParams(lp); } final LayoutParams sglp = (LayoutParams) lp; sglp.position = position; sglp.viewType = positionViewType; return view; } public GalleryThumbnailAdapter getAdapter() { return mAdapter; } public void setAdapter(GalleryThumbnailAdapter adapter) { if (mAdapter != null) { mAdapter.unregisterDataSetObserver(mObserver); } // TODO: If the new adapter says that there are stable IDs, remove certain layout records // and onscreen views if they have changed instead of removing all of the state here. clearAllState(); mAdapter = adapter; mDataChanged = true; mOldItemCount = mItemCount = adapter != null ? adapter.getCount() : 0; if (adapter != null) { adapter.registerDataSetObserver(mObserver); mRecycler.setViewTypeCount(adapter.getViewTypeCount()); mHasStableIds = adapter.hasStableIds(); } else { mHasStableIds = false; } populate(); } /** * Clear all state because the grid will be used for a completely different set of data. */ private void clearAllState() { // Clear all layout records and views removeAllViews(); // Reset to the top of the grid mFirstPosition = 0; // Clear recycler because there could be different view types now mRecycler.clear(); } @Override protected LayoutParams generateDefaultLayoutParams() { return new LayoutParams(LayoutParams.WRAP_CONTENT); } @Override protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) { return new LayoutParams(lp); } @Override protected boolean checkLayoutParams(ViewGroup.LayoutParams lp) { return lp instanceof LayoutParams; } @Override public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) { return new LayoutParams(getContext(), attrs); } public static class LayoutParams extends ViewGroup.LayoutParams { private static final int[] LAYOUT_ATTRS = new int[] { android.R.attr.layout_span }; private static final int SPAN_INDEX = 0; /** * The number of columns this item should span */ public int span = 1; /** * Item position this view represents */ int position; /** * Type of this view as reported by the adapter */ int viewType; /** * The column this view is occupying */ int column; /** * The stable ID of the item this view displays */ long id = -1; public LayoutParams(int height) { super(MATCH_PARENT, height); if (this.height == MATCH_PARENT) { Log.w(TAG, "Constructing LayoutParams with height MATCH_PARENT - " + "impossible! Falling back to WRAP_CONTENT"); this.height = WRAP_CONTENT; } } public LayoutParams(Context c, AttributeSet attrs) { super(c, attrs); if (this.width != MATCH_PARENT) { Log.w(TAG, "Inflation setting LayoutParams width to " + this.width + " - must be MATCH_PARENT"); this.width = MATCH_PARENT; } if (this.height == MATCH_PARENT) { Log.w(TAG, "Inflation setting LayoutParams height to MATCH_PARENT - " + "impossible! Falling back to WRAP_CONTENT"); this.height = WRAP_CONTENT; } TypedArray a = c.obtainStyledAttributes(attrs, LAYOUT_ATTRS); span = a.getInteger(SPAN_INDEX, 1); a.recycle(); } public LayoutParams(ViewGroup.LayoutParams other) { super(other); if (this.width != MATCH_PARENT) { Log.w(TAG, "Constructing LayoutParams with width " + this.width + " - must be MATCH_PARENT"); this.width = MATCH_PARENT; } if (this.height == MATCH_PARENT) { Log.w(TAG, "Constructing LayoutParams with height MATCH_PARENT - " + "impossible! Falling back to WRAP_CONTENT"); this.height = WRAP_CONTENT; } } } private class RecycleBin { private ArrayList<View>[] mScrapViews; private int mViewTypeCount; private int mMaxScrap; private SparseArray<View> mTransientStateViews; public void setViewTypeCount(int viewTypeCount) { if (viewTypeCount < 1) { throw new IllegalArgumentException( "Must have at least one view type (" + viewTypeCount + " types reported)"); } if (viewTypeCount == mViewTypeCount) { return; } ArrayList<View>[] scrapViews = new ArrayList[viewTypeCount]; for (int i = 0; i < viewTypeCount; i++) { scrapViews[i] = new ArrayList<View>(); } mViewTypeCount = viewTypeCount; mScrapViews = scrapViews; } public void clear() { final int typeCount = mViewTypeCount; for (int i = 0; i < typeCount; i++) { mScrapViews[i].clear(); } if (mTransientStateViews != null) { mTransientStateViews.clear(); } } public void clearTransientViews() { if (mTransientStateViews != null) { mTransientStateViews.clear(); } } public void addScrap(View v) { final LayoutParams lp = (LayoutParams) v.getLayoutParams(); if (ViewCompat.hasTransientState(v)) { if (mTransientStateViews == null) { mTransientStateViews = new SparseArray<View>(); } mTransientStateViews.put(lp.position, v); return; } final int childCount = getChildCount(); if (childCount > mMaxScrap) { mMaxScrap = childCount; } ArrayList<View> scrap = mScrapViews[lp.viewType]; if (scrap.size() < mMaxScrap) { scrap.add(v); } } public View getTransientStateView(int position) { if (mTransientStateViews == null) { return null; } final View result = mTransientStateViews.get(position); if (result != null) { mTransientStateViews.remove(position); } return result; } public View getScrapView(int type) { ArrayList<View> scrap = mScrapViews[type]; if (scrap.isEmpty()) { return null; } final int index = scrap.size() - 1; final View result = scrap.get(index); scrap.remove(index); return result; } } private class AdapterDataSetObserver extends DataSetObserver { @Override public void onChanged() { mDataChanged = true; mOldItemCount = mItemCount; mItemCount = mAdapter.getCount(); // TODO: Consider matching these back up if we have stable IDs. mRecycler.clearTransientViews(); if (!mHasStableIds) { recycleAllViews(); } // TODO: consider repopulating in a deferred runnable instead // (so that successive changes may still be batched) requestLayout(); } @Override public void onInvalidated() { } } }