src/com/android/car/radio/CarouselView.java - platform/packages/apps/Car/Radio - Git at Google

 /*
  * Copyright (C) 2016 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.car.radio;

 import android.content.Context;
 import android.content.res.TypedArray;
 import android.database.Observable;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;

 import java.util.ArrayList;

 /**
  * A View that displays a vertical list of child views provided by a {@link CarouselView.Adapter}.
  * The Views can be shifted up and down and will loop backwards on itself if the end is reached.
  * The View that is considered first to be displayed can be offset by a given amount, and the rest
  * of the Views will sandwich that first View.
  */
 public class CarouselView extends ViewGroup {
     private static final String TAG = "CarouselView";

     /**
      * The alpha is that is used for the view considered first in the carousel.
      */
     private static final float FIRST_VIEW_ALPHA = 1.f;

     /**
      * The alpha for all the other views in the carousel.
      */
     private static final float DEFAULT_VIEW_ALPHA = 0.24f;

     private CarouselView.Adapter mAdapter;
     private int mTopOffset;
     private int mItemMargin;

     /**
      * The position into the the data set in {@link #mAdapter} that will be displayed as the first
      * item in the carousel.
      */
     private int mStartPosition;

     /**
      * The number of views in {@link #mScrapViews} that have been bound with data and should be
      * displayed in the carousel. This number can be different from the size of {@code mScrapViews}.
      */
     private int mBoundViews;

     /**
      * A {@link ArrayList} of scrap Views that can be used to populate the carousel. The views
      * contained in this scrap will be the ones that are returned {@link #mAdapter}.
      */
     private ArrayList<View> mScrapViews = new ArrayList<>();

     public CarouselView(Context context) {
         super(context);
         init(context, null);
     }

     public CarouselView(Context context, AttributeSet attrs) {
         super(context, attrs);
         init(context, attrs);
     }

     public CarouselView(Context context, AttributeSet attrs, int defStyleAttrs) {
         super(context, attrs, defStyleAttrs);
         init(context, attrs);
     }

     public CarouselView(Context context, AttributeSet attrs, int defStyleAttrs, int defStyleRes) {
         super(context, attrs, defStyleAttrs, defStyleRes);
         init(context, attrs);
     }

     /**
      * Initializes the starting top offset and margins between each of the items in the carousel.
      */
     private void init(Context context, AttributeSet attrs) {
         TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CarouselView);

         try {
             setTopOffset(ta.getDimensionPixelSize(R.styleable.CarouselView_topOffset, 0));
             setItemMargins(ta.getDimensionPixelSize(R.styleable.CarouselView_itemMargins, 0));
         } finally {
             ta.recycle();
         }
     }

     /**
      * Sets the adapter that will provide the Views to be displayed in the carousel.
      */
     public void setAdapter(CarouselView.Adapter adapter) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "setAdapter(): " + adapter);
         }

         if (mAdapter != null) {
             mAdapter.unregisterAll();
         }

         mAdapter = adapter;

         // Clear the scrap views because the Views returned from the adapter can be different from
         // an adapter that was previously set.
         mScrapViews.clear();

         if (mAdapter != null) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "adapter item count: " + adapter.getItemCount());
             }

             mScrapViews.ensureCapacity(adapter.getItemCount());
             mAdapter.registerObserver(this);
         }
     }

     /**
      * Sets the amount by which the first view in the carousel will be offset from the top of the
      * carousel. The last item and second item will sandwich this first view and expand upwards
      * and downwards respectively as space permits.
      *
      * <p>This value can be set in XML with the value {@code app:topOffset}.
      */
     public void setTopOffset(int topOffset) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "setTopOffset(): " + topOffset);
         }

         mTopOffset = topOffset;
     }

     /**
      * Sets the amount of space between each item in the carousel.
      *
      * <p>This value can be set in XML with the value {@code app:itemMargins}.
      */
     public void setItemMargins(int itemMargin) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "setItemMargins(): " + itemMargin);
         }

         mItemMargin = itemMargin;
     }

     /**
      * Shifts the carousel to the specified position.
      */
     public void shiftToPosition(int position) {
         if (mAdapter == null || position >= mAdapter.getItemCount() || position < 0) {
             return;
         }

         mStartPosition = position;
         requestLayout();
     }

     @Override
     protected void onMeasure(int widthSpec, int heightSpec) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "onMeasure()");
         }

         removeAllViewsInLayout();

         // If there is no adapter, then have the carousel take up no space.
         if (mAdapter == null) {
             Log.w(TAG, "No adapter set on this CarouselView. "
                     + "Setting measured dimensions as (0, 0)");
             setMeasuredDimension(0, 0);
             return;
         }

         int widthMode = MeasureSpec.getMode(widthSpec);
         int heightMode = MeasureSpec.getMode(heightSpec);

         int requestedHeight;
         if (heightMode == MeasureSpec.UNSPECIFIED) {
             requestedHeight = getDefaultHeight();
         } else {
             requestedHeight = MeasureSpec.getSize(heightSpec);
         }

         int requestedWidth;
         if (widthMode == MeasureSpec.UNSPECIFIED) {
             requestedWidth = getDefaultWidth();
         } else {
             requestedWidth = MeasureSpec.getSize(widthSpec);
         }

         // The children of this carousel can take up as much space as this carousel has been
         // set to.
         int childWidthSpec = MeasureSpec.makeMeasureSpec(requestedWidth, MeasureSpec.AT_MOST);
         int childHeightSpec = MeasureSpec.makeMeasureSpec(requestedHeight, MeasureSpec.AT_MOST);

         int availableHeight = requestedHeight;
         int largestWidth = 0;
         int itemCount = mAdapter.getItemCount();
         int currentAdapterPosition = mStartPosition;

         mBoundViews = 0;

         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("onMeasure(); requestedWidth: %d, requestedHeight: %d, "
                     + "availableHeight: %d", requestedWidth, requestedHeight, availableHeight));
         }

         int availableHeightDownwards = availableHeight - mTopOffset;

         // Starting from the top offset, measure the views that can fit downwards.
         while (availableHeightDownwards >= 0) {
             View childView = getChildView(mBoundViews);

             mAdapter.bindView(childView, currentAdapterPosition,
                     currentAdapterPosition == mStartPosition);
             mBoundViews++;

             // Ensure that only the first view has full alpha.
             if (currentAdapterPosition == mStartPosition) {
                 childView.setAlpha(FIRST_VIEW_ALPHA);
             } else {
                 childView.setAlpha(DEFAULT_VIEW_ALPHA);
             }

             childView.measure(childWidthSpec, childHeightSpec);

             largestWidth = Math.max(largestWidth, childView.getMeasuredWidth());
             availableHeightDownwards -= childView.getMeasuredHeight();

             // Wrap the current adapter position if necessary.
             if (++currentAdapterPosition == itemCount) {
                 currentAdapterPosition = 0;
             }

             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "Measuring views downwards; current position: "
                         + currentAdapterPosition);
             }

             // Break if there are no more views to bind.
             if (mBoundViews == itemCount) {
                 break;
             }
         }

         int availableHeightUpwards = mTopOffset;
         currentAdapterPosition = mStartPosition;

         // Starting from the top offset, measure the views that can fit upwards.
         while (availableHeightUpwards >= 0) {
             // Wrap the current adapter position if necessary.
             if (--currentAdapterPosition < 0) {
                 currentAdapterPosition = itemCount - 1;
             }

             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "Measuring views upwards; current position: "
                         + currentAdapterPosition);
             }

             View childView = getChildView(mBoundViews);

             mAdapter.bindView(childView, currentAdapterPosition,
                     currentAdapterPosition == mStartPosition);
             mBoundViews++;

             // We know that the first view will be measured in the "downwards" pass, so all these
             // views can have DEFAULT_VIEW_ALPHA.
             childView.setAlpha(DEFAULT_VIEW_ALPHA);
             childView.measure(childWidthSpec, childHeightSpec);

             largestWidth = Math.max(largestWidth, childView.getMeasuredWidth());
             availableHeightUpwards -= childView.getMeasuredHeight();

             // Break if there are no more views to bind.
             if (mBoundViews == itemCount) {
                 break;
             }
         }

         int width = widthMode == MeasureSpec.EXACTLY
                 ? requestedWidth
                 : Math.min(largestWidth, requestedWidth);

         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("Measure finished. Largest width is %s; "
                     + "setting final width as %s.", largestWidth, width));
         }

         setMeasuredDimension(width, requestedHeight);
     }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         int height = b - t;
         int width = r - l;

         int top = mTopOffset;
         int viewsLaidOut = 0;
         int currentPosition = 0;
         LayoutParams layoutParams = getLayoutParams();

         // Double check that the item count has not changed since the views have been bound.
         if (mBoundViews > mAdapter.getItemCount()) {
             return;
         }

         // Start laying out the views from the first position downwards.
         for (; viewsLaidOut < mBoundViews; viewsLaidOut++) {
             View childView = mScrapViews.get(currentPosition);
             addViewInLayout(childView, -1, layoutParams);
             int measuredHeight = childView.getMeasuredHeight();

             childView.layout(width - childView.getMeasuredWidth(), top, width,
                     top + measuredHeight);

             top += mItemMargin + measuredHeight;

             // Wrap the current position if necessary.
             if (++currentPosition >= mBoundViews) {
                 currentPosition = 0;
             }

             // Check if there is still space to fit another view. If not, then stop layout.
             if (top >= height) {
                 // Increase the number of views laid out by 1 since this usually will happen at the
                 // end of the loop, but we are breaking out of it.
                 viewsLaidOut++;
                 break;
             }
         }

         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("onLayout(). First pass laid out %s views", viewsLaidOut));
         }

         // Reset the top position to the first position's top and the starting position.
         top = mTopOffset;
         currentPosition = 0;

         // Now, if there are any views remaining, back-fill the space above the first position.
         for (; viewsLaidOut < mBoundViews; viewsLaidOut++) {
             // Wrap the current position if necessary. Since this is a back-fill, we will subtract
             // from the current position.
             if (--currentPosition < 0) {
                 currentPosition = mBoundViews - 1;
             }

             View childView = mScrapViews.get(currentPosition);
             addViewInLayout(childView, -1, layoutParams);
             int measuredHeight = childView.getMeasuredHeight();

             top -= measuredHeight + mItemMargin;

             childView.layout(width - childView.getMeasuredWidth(), top, width,
                     top + measuredHeight);

             // Check if there is still space to fit another view.
             if (top <= 0) {
                 // Although this value is not technically needed, increasing its value so that the
                 // debug statement will print out the correct value.
                 viewsLaidOut++;
                 break;
             }
         }

         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("onLayout(). Second pass total laid out %s views",
                     viewsLaidOut));
         }
     }

     /**
      * Returns the {@link View} that should be drawn at the given position.
      */
     private View getChildView(int position) {
         View childView;

         // Check if there is already a View in the scrap pile of Views that can be used. Otherwise,
         // create a new View and add it to the scrap.
         if (mScrapViews.size() > position) {
             childView = mScrapViews.get(position);
         } else {
             childView = mAdapter.createView(this /* parent */);
             mScrapViews.add(childView);
         }

         return childView;
     }

     /**
      * Returns the default height that the {@link CarouselView} will take up. This will be the
      * height of the current screen.
      */
     private int getDefaultHeight() {
         return getDisplayMetrics(getContext()).heightPixels;
     }

     /**
      * Returns the default width that the {@link CarouselView} will take up. This will be the width
      * of the current screen.
      */
     private int getDefaultWidth() {
         return getDisplayMetrics(getContext()).widthPixels;
     }

     /**
      * Returns a {@link DisplayMetrics} object that can be used to query the height and width of the
      * current device's screen.
      */
     private static DisplayMetrics getDisplayMetrics(Context context) {
         WindowManager windowManager = (WindowManager) context.getSystemService(
                 Context.WINDOW_SERVICE);
         DisplayMetrics displayMetrics = new DisplayMetrics();
         windowManager.getDefaultDisplay().getMetrics(displayMetrics);
         return displayMetrics;
     }

     /**
      * A data set adapter for the {@link CarouselView} that is responsible for providing the views
      * to be displayed as well as binding data on those views.
      */
     public static abstract class Adapter extends Observable<CarouselView> {
         /**
          * Returns a View to be displayed. The views returned should all be the same.
          *
          * @param parent The {@link CarouselView} that the views will be attached to.
          * @return A non-{@code null} View.
          */
         public abstract View createView(ViewGroup parent);

         /**
          * Binds the given View with data. The View passed to this method will be the same View
          * returned by {@link #createView(ViewGroup)}.
          *
          * @param view The View to bind with data.
          * @param position The position of the View in the carousel.
          * @param isFirstView {@code true} if the view being bound is the first view in the
          *                    carousel.
          */
         public abstract void bindView(View view, int position, boolean isFirstView);

         /**
          * Returns the total number of unique items that will be displayed in the
          * {@link CarouselView}.
          */
         public abstract int getItemCount();

         /**
          * Notify the {@link CarouselView} that the data set has changed. This will cause the
          * {@link CarouselView} to re-layout itself.
          */
         public final void notifyDataSetChanged() {
             if (mObservers.size() > 0) {
                 for (CarouselView carouselView : mObservers) {
                     carouselView.requestLayout();
                 }
             }
         }
     }
 }
	/*
	* Copyright (C) 2016 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.car.radio;

	import android.content.Context;
	import android.content.res.TypedArray;
	import android.database.Observable;
	import android.util.AttributeSet;
	import android.util.DisplayMetrics;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;
	import android.view.WindowManager;

	import java.util.ArrayList;

	/**
	* A View that displays a vertical list of child views provided by a {@link CarouselView.Adapter}.
	* The Views can be shifted up and down and will loop backwards on itself if the end is reached.
	* The View that is considered first to be displayed can be offset by a given amount, and the rest
	* of the Views will sandwich that first View.
	*/
	public class CarouselView extends ViewGroup {
	private static final String TAG = "CarouselView";

	/**
	* The alpha is that is used for the view considered first in the carousel.
	*/
	private static final float FIRST_VIEW_ALPHA = 1.f;

	/**
	* The alpha for all the other views in the carousel.
	*/
	private static final float DEFAULT_VIEW_ALPHA = 0.24f;

	private CarouselView.Adapter mAdapter;
	private int mTopOffset;
	private int mItemMargin;

	/**
	* The position into the the data set in {@link #mAdapter} that will be displayed as the first
	* item in the carousel.
	*/
	private int mStartPosition;

	/**
	* The number of views in {@link #mScrapViews} that have been bound with data and should be
	* displayed in the carousel. This number can be different from the size of {@code mScrapViews}.
	*/
	private int mBoundViews;

	/**
	* A {@link ArrayList} of scrap Views that can be used to populate the carousel. The views
	* contained in this scrap will be the ones that are returned {@link #mAdapter}.
	*/
	private ArrayList<View> mScrapViews = new ArrayList<>();

	public CarouselView(Context context) {
	super(context);
	init(context, null);
	}

	public CarouselView(Context context, AttributeSet attrs) {
	super(context, attrs);
	init(context, attrs);
	}

	public CarouselView(Context context, AttributeSet attrs, int defStyleAttrs) {
	super(context, attrs, defStyleAttrs);
	init(context, attrs);
	}

	public CarouselView(Context context, AttributeSet attrs, int defStyleAttrs, int defStyleRes) {
	super(context, attrs, defStyleAttrs, defStyleRes);
	init(context, attrs);
	}

	/**
	* Initializes the starting top offset and margins between each of the items in the carousel.
	*/
	private void init(Context context, AttributeSet attrs) {
	TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CarouselView);

	try {
	setTopOffset(ta.getDimensionPixelSize(R.styleable.CarouselView_topOffset, 0));
	setItemMargins(ta.getDimensionPixelSize(R.styleable.CarouselView_itemMargins, 0));
	} finally {
	ta.recycle();
	}
	}

	/**
	* Sets the adapter that will provide the Views to be displayed in the carousel.
	*/
	public void setAdapter(CarouselView.Adapter adapter) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "setAdapter(): " + adapter);
	}

	if (mAdapter != null) {
	mAdapter.unregisterAll();
	}

	mAdapter = adapter;

	// Clear the scrap views because the Views returned from the adapter can be different from
	// an adapter that was previously set.
	mScrapViews.clear();

	if (mAdapter != null) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "adapter item count: " + adapter.getItemCount());
	}

	mScrapViews.ensureCapacity(adapter.getItemCount());
	mAdapter.registerObserver(this);
	}
	}

	/**
	* Sets the amount by which the first view in the carousel will be offset from the top of the
	* carousel. The last item and second item will sandwich this first view and expand upwards
	* and downwards respectively as space permits.
	*
	* <p>This value can be set in XML with the value {@code app:topOffset}.
	*/
	public void setTopOffset(int topOffset) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "setTopOffset(): " + topOffset);
	}

	mTopOffset = topOffset;
	}

	/**
	* Sets the amount of space between each item in the carousel.
	*
	* <p>This value can be set in XML with the value {@code app:itemMargins}.
	*/
	public void setItemMargins(int itemMargin) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "setItemMargins(): " + itemMargin);
	}

	mItemMargin = itemMargin;
	}

	/**
	* Shifts the carousel to the specified position.
	*/
	public void shiftToPosition(int position) {
	if (mAdapter == null \|\| position >= mAdapter.getItemCount() \|\| position < 0) {
	return;
	}

	mStartPosition = position;
	requestLayout();
	}

	@Override
	protected void onMeasure(int widthSpec, int heightSpec) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onMeasure()");
	}

	removeAllViewsInLayout();

	// If there is no adapter, then have the carousel take up no space.
	if (mAdapter == null) {
	Log.w(TAG, "No adapter set on this CarouselView. "
	+ "Setting measured dimensions as (0, 0)");
	setMeasuredDimension(0, 0);
	return;
	}

	int widthMode = MeasureSpec.getMode(widthSpec);
	int heightMode = MeasureSpec.getMode(heightSpec);

	int requestedHeight;
	if (heightMode == MeasureSpec.UNSPECIFIED) {
	requestedHeight = getDefaultHeight();
	} else {
	requestedHeight = MeasureSpec.getSize(heightSpec);
	}

	int requestedWidth;
	if (widthMode == MeasureSpec.UNSPECIFIED) {
	requestedWidth = getDefaultWidth();
	} else {
	requestedWidth = MeasureSpec.getSize(widthSpec);
	}

	// The children of this carousel can take up as much space as this carousel has been
	// set to.
	int childWidthSpec = MeasureSpec.makeMeasureSpec(requestedWidth, MeasureSpec.AT_MOST);
	int childHeightSpec = MeasureSpec.makeMeasureSpec(requestedHeight, MeasureSpec.AT_MOST);

	int availableHeight = requestedHeight;
	int largestWidth = 0;
	int itemCount = mAdapter.getItemCount();
	int currentAdapterPosition = mStartPosition;

	mBoundViews = 0;

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("onMeasure(); requestedWidth: %d, requestedHeight: %d, "
	+ "availableHeight: %d", requestedWidth, requestedHeight, availableHeight));
	}

	int availableHeightDownwards = availableHeight - mTopOffset;

	// Starting from the top offset, measure the views that can fit downwards.
	while (availableHeightDownwards >= 0) {
	View childView = getChildView(mBoundViews);

	mAdapter.bindView(childView, currentAdapterPosition,
	currentAdapterPosition == mStartPosition);
	mBoundViews++;

	// Ensure that only the first view has full alpha.
	if (currentAdapterPosition == mStartPosition) {
	childView.setAlpha(FIRST_VIEW_ALPHA);
	} else {
	childView.setAlpha(DEFAULT_VIEW_ALPHA);
	}

	childView.measure(childWidthSpec, childHeightSpec);

	largestWidth = Math.max(largestWidth, childView.getMeasuredWidth());
	availableHeightDownwards -= childView.getMeasuredHeight();

	// Wrap the current adapter position if necessary.
	if (++currentAdapterPosition == itemCount) {
	currentAdapterPosition = 0;
	}

	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "Measuring views downwards; current position: "
	+ currentAdapterPosition);
	}

	// Break if there are no more views to bind.
	if (mBoundViews == itemCount) {
	break;
	}
	}

	int availableHeightUpwards = mTopOffset;
	currentAdapterPosition = mStartPosition;

	// Starting from the top offset, measure the views that can fit upwards.
	while (availableHeightUpwards >= 0) {
	// Wrap the current adapter position if necessary.
	if (--currentAdapterPosition < 0) {
	currentAdapterPosition = itemCount - 1;
	}

	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "Measuring views upwards; current position: "
	+ currentAdapterPosition);
	}

	View childView = getChildView(mBoundViews);

	mAdapter.bindView(childView, currentAdapterPosition,
	currentAdapterPosition == mStartPosition);
	mBoundViews++;

	// We know that the first view will be measured in the "downwards" pass, so all these
	// views can have DEFAULT_VIEW_ALPHA.
	childView.setAlpha(DEFAULT_VIEW_ALPHA);
	childView.measure(childWidthSpec, childHeightSpec);

	largestWidth = Math.max(largestWidth, childView.getMeasuredWidth());
	availableHeightUpwards -= childView.getMeasuredHeight();

	// Break if there are no more views to bind.
	if (mBoundViews == itemCount) {
	break;
	}
	}

	int width = widthMode == MeasureSpec.EXACTLY
	? requestedWidth
	: Math.min(largestWidth, requestedWidth);

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("Measure finished. Largest width is %s; "
	+ "setting final width as %s.", largestWidth, width));
	}

	setMeasuredDimension(width, requestedHeight);
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	int height = b - t;
	int width = r - l;

	int top = mTopOffset;
	int viewsLaidOut = 0;
	int currentPosition = 0;
	LayoutParams layoutParams = getLayoutParams();

	// Double check that the item count has not changed since the views have been bound.
	if (mBoundViews > mAdapter.getItemCount()) {
	return;
	}

	// Start laying out the views from the first position downwards.
	for (; viewsLaidOut < mBoundViews; viewsLaidOut++) {
	View childView = mScrapViews.get(currentPosition);
	addViewInLayout(childView, -1, layoutParams);
	int measuredHeight = childView.getMeasuredHeight();

	childView.layout(width - childView.getMeasuredWidth(), top, width,
	top + measuredHeight);

	top += mItemMargin + measuredHeight;

	// Wrap the current position if necessary.
	if (++currentPosition >= mBoundViews) {
	currentPosition = 0;
	}

	// Check if there is still space to fit another view. If not, then stop layout.
	if (top >= height) {
	// Increase the number of views laid out by 1 since this usually will happen at the
	// end of the loop, but we are breaking out of it.
	viewsLaidOut++;
	break;
	}
	}

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("onLayout(). First pass laid out %s views", viewsLaidOut));
	}

	// Reset the top position to the first position's top and the starting position.
	top = mTopOffset;
	currentPosition = 0;

	// Now, if there are any views remaining, back-fill the space above the first position.
	for (; viewsLaidOut < mBoundViews; viewsLaidOut++) {
	// Wrap the current position if necessary. Since this is a back-fill, we will subtract
	// from the current position.
	if (--currentPosition < 0) {
	currentPosition = mBoundViews - 1;
	}

	View childView = mScrapViews.get(currentPosition);
	addViewInLayout(childView, -1, layoutParams);
	int measuredHeight = childView.getMeasuredHeight();

	top -= measuredHeight + mItemMargin;

	childView.layout(width - childView.getMeasuredWidth(), top, width,
	top + measuredHeight);

	// Check if there is still space to fit another view.
	if (top <= 0) {
	// Although this value is not technically needed, increasing its value so that the
	// debug statement will print out the correct value.
	viewsLaidOut++;
	break;
	}
	}

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("onLayout(). Second pass total laid out %s views",
	viewsLaidOut));
	}
	}

	/**
	* Returns the {@link View} that should be drawn at the given position.
	*/
	private View getChildView(int position) {
	View childView;

	// Check if there is already a View in the scrap pile of Views that can be used. Otherwise,
	// create a new View and add it to the scrap.
	if (mScrapViews.size() > position) {
	childView = mScrapViews.get(position);
	} else {
	childView = mAdapter.createView(this /* parent */);
	mScrapViews.add(childView);
	}

	return childView;
	}

	/**
	* Returns the default height that the {@link CarouselView} will take up. This will be the
	* height of the current screen.
	*/
	private int getDefaultHeight() {
	return getDisplayMetrics(getContext()).heightPixels;
	}

	/**
	* Returns the default width that the {@link CarouselView} will take up. This will be the width
	* of the current screen.
	*/
	private int getDefaultWidth() {
	return getDisplayMetrics(getContext()).widthPixels;
	}

	/**
	* Returns a {@link DisplayMetrics} object that can be used to query the height and width of the
	* current device's screen.
	*/
	private static DisplayMetrics getDisplayMetrics(Context context) {
	WindowManager windowManager = (WindowManager) context.getSystemService(
	Context.WINDOW_SERVICE);
	DisplayMetrics displayMetrics = new DisplayMetrics();
	windowManager.getDefaultDisplay().getMetrics(displayMetrics);
	return displayMetrics;
	}

	/**
	* A data set adapter for the {@link CarouselView} that is responsible for providing the views
	* to be displayed as well as binding data on those views.
	*/
	public static abstract class Adapter extends Observable<CarouselView> {
	/**
	* Returns a View to be displayed. The views returned should all be the same.
	*
	* @param parent The {@link CarouselView} that the views will be attached to.
	* @return A non-{@code null} View.
	*/
	public abstract View createView(ViewGroup parent);

	/**
	* Binds the given View with data. The View passed to this method will be the same View
	* returned by {@link #createView(ViewGroup)}.
	*
	* @param view The View to bind with data.
	* @param position The position of the View in the carousel.
	* @param isFirstView {@code true} if the view being bound is the first view in the
	* carousel.
	*/
	public abstract void bindView(View view, int position, boolean isFirstView);

	/**
	* Returns the total number of unique items that will be displayed in the
	* {@link CarouselView}.
	*/
	public abstract int getItemCount();

	/**
	* Notify the {@link CarouselView} that the data set has changed. This will cause the
	* {@link CarouselView} to re-layout itself.
	*/
	public final void notifyDataSetChanged() {
	if (mObservers.size() > 0) {
	for (CarouselView carouselView : mObservers) {
	carouselView.requestLayout();
	}
	}
	}
	}
	}