src/com/android/contacts/detail/ContactDetailTabCarousel.java - platform/packages/apps/Contacts - Git at Google

 /*
  * Copyright (C) 2011 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.contacts.detail;

 import android.content.Context;
 import android.content.res.Resources;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.util.TypedValue;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.View.OnTouchListener;
 import android.view.ViewPropertyAnimator;
 import android.widget.HorizontalScrollView;
 import android.widget.ImageView;
 import android.widget.TextView;

 import com.android.contacts.R;
 import com.android.contacts.model.Contact;
 import com.android.contacts.util.MoreMath;
 import com.android.contacts.util.SchedulingUtils;

 /**
  * This is a horizontally scrolling carousel with 2 tabs: one to see info about the contact and
  * one to see updates from the contact.
  */
 public class ContactDetailTabCarousel extends HorizontalScrollView implements OnTouchListener {

     private static final String TAG = ContactDetailTabCarousel.class.getSimpleName();

     private static final int TRANSITION_TIME = 200;
     private static final int TRANSITION_MOVE_IN_TIME = 150;

     private static final int TAB_INDEX_ABOUT = 0;
     private static final int TAB_INDEX_UPDATES = 1;
     private static final int TAB_COUNT = 2;

     /** Tab width as defined as a fraction of the screen width */
     private float mTabWidthScreenWidthFraction;

     /** Tab height as defined as a fraction of the screen width */
     private float mTabHeightScreenWidthFraction;

     /** Height in pixels of the shadow under the tab carousel */
     private int mTabShadowHeight;

     private ImageView mPhotoView;
     private View mPhotoViewOverlay;
     private TextView mStatusView;
     private ImageView mStatusPhotoView;
     private final ContactDetailPhotoSetter mPhotoSetter = new ContactDetailPhotoSetter();

     private Listener mListener;

     private int mCurrentTab = TAB_INDEX_ABOUT;

     private View mTabAndShadowContainer;
     private View mShadow;
     private CarouselTab mAboutTab;
     private View mTabDivider;
     private CarouselTab mUpdatesTab;

     /** Last Y coordinate of the carousel when the tab at the given index was selected */
     private final float[] mYCoordinateArray = new float[TAB_COUNT];

     private int mTabDisplayLabelHeight;

     private boolean mScrollToCurrentTab = false;
     private int mLastScrollPosition = Integer.MIN_VALUE;
     private int mAllowedHorizontalScrollLength = Integer.MIN_VALUE;
     private int mAllowedVerticalScrollLength = Integer.MIN_VALUE;

     /** Factor to scale scroll-amount sent to listeners. */
     private float mScrollScaleFactor = 1.0f;

     private static final float MAX_ALPHA = 0.5f;

     /**
      * Interface for callbacks invoked when the user interacts with the carousel.
      */
     public interface Listener {
         public void onTouchDown();
         public void onTouchUp();

         public void onScrollChanged(int l, int t, int oldl, int oldt);
         public void onTabSelected(int position);
     }

     public ContactDetailTabCarousel(Context context, AttributeSet attrs) {
         super(context, attrs);

         setOnTouchListener(this);

         Resources resources = mContext.getResources();
         mTabDisplayLabelHeight = resources.getDimensionPixelSize(
                 R.dimen.detail_tab_carousel_tab_label_height);
         mTabShadowHeight = resources.getDimensionPixelSize(
                 R.dimen.detail_contact_photo_shadow_height);
         mTabWidthScreenWidthFraction = resources.getFraction(
                 R.fraction.tab_width_screen_width_percentage, 1, 1);
         mTabHeightScreenWidthFraction = resources.getFraction(
                 R.fraction.tab_height_screen_width_percentage, 1, 1);
     }

     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();
         mTabAndShadowContainer = findViewById(R.id.tab_and_shadow_container);
         mAboutTab = (CarouselTab) findViewById(R.id.tab_about);
         mAboutTab.setLabel(mContext.getString(R.string.contactDetailAbout));
         mAboutTab.setOverlayOnClickListener(mAboutTabTouchInterceptListener);

         mTabDivider = findViewById(R.id.tab_divider);

         mUpdatesTab = (CarouselTab) findViewById(R.id.tab_update);
         mUpdatesTab.setLabel(mContext.getString(R.string.contactDetailUpdates));
         mUpdatesTab.setOverlayOnClickListener(mUpdatesTabTouchInterceptListener);

         mShadow = findViewById(R.id.shadow);

         // Retrieve the photo view for the "about" tab
         // TODO: This should be moved down to mAboutTab, so that it hosts its own controls
         mPhotoView = (ImageView) mAboutTab.findViewById(R.id.photo);
         mPhotoViewOverlay = mAboutTab.findViewById(R.id.photo_overlay);

         // Retrieve the social update views for the "updates" tab
         // TODO: This should be moved down to mUpdatesTab, so that it hosts its own controls
         mStatusView = (TextView) mUpdatesTab.findViewById(R.id.status);
         mStatusPhotoView = (ImageView) mUpdatesTab.findViewById(R.id.status_photo);

         // Workaround for framework issue... it shouldn't be necessary to have a
         // clickable object in the hierarchy, but if not the horizontal scroll
         // behavior doesn't work. Note: the "About" tab doesn't need this
         // because we set a real click-handler elsewhere.
         mStatusView.setClickable(true);
         mStatusPhotoView.setClickable(true);
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int screenWidth = MeasureSpec.getSize(widthMeasureSpec);
         // Compute the width of a tab as a fraction of the screen width
         int tabWidth = Math.round(mTabWidthScreenWidthFraction * screenWidth);

         // Find the allowed scrolling length by subtracting the current visible screen width
         // from the total length of the tabs.
         mAllowedHorizontalScrollLength = tabWidth * TAB_COUNT - screenWidth;

         // Scrolling by mAllowedHorizontalScrollLength causes listeners to
         // scroll by the entire screen amount; compute the scale-factor
         // necessary to make this so.
         if (mAllowedHorizontalScrollLength == 0) {
             // Guard against divide-by-zero.
             // Note: this hard-coded value prevents a crash, but won't result in the
             // desired scrolling behavior.  We rely on the framework calling onMeasure()
             // again with a non-zero screen width.
             mScrollScaleFactor = 1.0f;
             Log.w(TAG, "set scale-factor to 1.0 to avoid divide-by-zero");
         } else {
             mScrollScaleFactor = screenWidth / mAllowedHorizontalScrollLength;
         }

         int tabHeight = Math.round(screenWidth * mTabHeightScreenWidthFraction) + mTabShadowHeight;
         // Set the child {@link LinearLayout} to be TAB_COUNT * the computed tab width so that the
         // {@link LinearLayout}'s children (which are the tabs) will evenly split that width.
         if (getChildCount() > 0) {
             View child = getChildAt(0);

             // add 1 dip of separation between the tabs
             final int seperatorPixels =
                     (int)(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1,
                     getResources().getDisplayMetrics()) + 0.5f);

             child.measure(
                     MeasureSpec.makeMeasureSpec(
                             TAB_COUNT * tabWidth +
                             (TAB_COUNT - 1) * seperatorPixels, MeasureSpec.EXACTLY),
                     MeasureSpec.makeMeasureSpec(tabHeight, MeasureSpec.EXACTLY));
         }

         mAllowedVerticalScrollLength = tabHeight - mTabDisplayLabelHeight - mTabShadowHeight;
         setMeasuredDimension(
                 resolveSize(screenWidth, widthMeasureSpec),
                 resolveSize(tabHeight, heightMeasureSpec));
     }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);

         // Defer this stuff until after the layout has finished.  This is because
         // updateAlphaLayers() ultimately results in another layout request, and
         // the framework currently can't handle this safely.
         if (!mScrollToCurrentTab) return;
         mScrollToCurrentTab = false;
         SchedulingUtils.doAfterLayout(this, new Runnable() {
             @Override
             public void run() {
                 scrollTo(mCurrentTab == TAB_INDEX_ABOUT ? 0 : mAllowedHorizontalScrollLength, 0);
                 updateAlphaLayers();
             }
         });
     }

     /** When clicked, selects the corresponding tab. */
     private class TabClickListener implements OnClickListener {
         private final int mTab;

         public TabClickListener(int tab) {
             super();
             mTab = tab;
         }

         @Override
         public void onClick(View v) {
             mListener.onTabSelected(mTab);
         }
     }

     private final TabClickListener mAboutTabTouchInterceptListener =
             new TabClickListener(TAB_INDEX_ABOUT);

     private final TabClickListener mUpdatesTabTouchInterceptListener =
             new TabClickListener(TAB_INDEX_UPDATES);

     /**
      * Does in "appear" animation to allow a seamless transition from
      * the "No updates" mode.
      * @param width Width of the container. As we haven't been layed out yet, we can't know
      * @param scrollOffset The offset by how far we scrolled, where 0=not scrolled, -x=scrolled by
      * x pixels, Integer.MIN_VALUE=scrolled so far that the image is not visible in "no updates"
      * mode of this screen
      */
     public void animateAppear(int width, int scrollOffset) {
         final float photoHeight = mTabHeightScreenWidthFraction * width;
         final boolean animateZoomAndFade;
         int pixelsToScrollVertically = 0;

         // Depending on how far we are scrolled down, there is one of three animations:
         //   - Zoom and fade the picture (if it is still visible)
         //   - Scroll, zoom and fade (if the picture is mostly invisible and we now have a
         //     bigger visible region due to the pinning)
         //   - Just scroll if the picture is completely invisible. This time, no zoom is needed
         if (scrollOffset == Integer.MIN_VALUE) {
             // animate in completely by scrolling. no need for zooming here
             pixelsToScrollVertically = mTabDisplayLabelHeight;
             animateZoomAndFade = false;
         } else {
             final int pixelsOfPhotoLeft = Math.round(photoHeight) + scrollOffset;
             if (pixelsOfPhotoLeft > mTabDisplayLabelHeight) {
                 // nothing to scroll
                 pixelsToScrollVertically = 0;
             } else {
                 pixelsToScrollVertically = mTabDisplayLabelHeight - pixelsOfPhotoLeft;
             }
             animateZoomAndFade = true;
         }

         if (pixelsToScrollVertically != 0) {
             // We can't animate ourselves here, because our own translation is needed for the user's
             // scrolling. Instead, we use our only child. As we are transparent, that is just as
             // good
             mTabAndShadowContainer.setTranslationY(-pixelsToScrollVertically);
             final ViewPropertyAnimator animator = mTabAndShadowContainer.animate();
             animator.translationY(0.0f);
             animator.setDuration(TRANSITION_MOVE_IN_TIME);
         }

         if (animateZoomAndFade) {
             // Hack: We have two types of possible layouts:
             //   If the picture is square, it is square in both "with updates" and "without updates"
             //     --> no need for scale animation here
             //     example: 10inch tablet portrait
             //   If the picture is non-square, it is full-width in "without updates" and something
             //     arbitrary in "with updates"
             //     --> do animation with container
             //     example: 4.6inch phone portrait
             final boolean squarePicture =
                     mTabWidthScreenWidthFraction == mTabHeightScreenWidthFraction;
             final int firstTransitionTime;
             if (squarePicture) {
                 firstTransitionTime = 0;
             } else {
                 // For x, we need to scale our container so we'll animate the whole tab
                 // (unfortunately, we need to have the text invisible during this transition as it
                 // would also be stretched)
                 float revScale = 1.0f/mTabWidthScreenWidthFraction;
                 mAboutTab.setScaleX(revScale);
                 mAboutTab.setPivotX(0.0f);
                 final ViewPropertyAnimator aboutAnimator = mAboutTab.animate();
                 aboutAnimator.setDuration(TRANSITION_TIME);
                 aboutAnimator.scaleX(1.0f);

                 // For y, we need to scale only the picture itself because we want it to be cropped
                 mPhotoView.setScaleY(revScale);
                 mPhotoView.setPivotY(photoHeight * 0.5f);
                 final ViewPropertyAnimator photoAnimator = mPhotoView.animate();
                 photoAnimator.setDuration(TRANSITION_TIME);
                 photoAnimator.scaleY(1.0f);
                 firstTransitionTime = TRANSITION_TIME;
             }

             // Animate in the labels after the above transition is finished
             mAboutTab.fadeInLabelViewAnimator(firstTransitionTime, true);
             mUpdatesTab.fadeInLabelViewAnimator(firstTransitionTime, false);

             final float pixelsToTranslate = (1.0f - mTabWidthScreenWidthFraction) * width;
             // Views to translate
             for (View view : new View[] { mUpdatesTab, mTabDivider }) {
                 view.setTranslationX(pixelsToTranslate);
                 final ViewPropertyAnimator translateAnimator = view.animate();
                 translateAnimator.translationX(0.0f);
                 translateAnimator.setDuration(TRANSITION_TIME);
             }

             // Another hack: If the picture is square, there is no shadow in "Without updates"
             //    --> fade it in after the translations are done
             if (squarePicture) {
                 mShadow.setAlpha(0.0f);
                 mShadow.animate().setStartDelay(TRANSITION_TIME).alpha(1.0f);
             }
         }
     }

     private void updateAlphaLayers() {
         float alpha = mLastScrollPosition * MAX_ALPHA / mAllowedHorizontalScrollLength;
         alpha = MoreMath.clamp(alpha, 0.0f, 1.0f);
         mAboutTab.setAlphaLayerValue(alpha);
         mUpdatesTab.setAlphaLayerValue(MAX_ALPHA - alpha);
     }

     @Override
     protected void onScrollChanged(int x, int y, int oldX, int oldY) {
         super.onScrollChanged(x, y, oldX, oldY);

         // Guard against framework issue where onScrollChanged() is called twice
         // for each touch-move event.  This wreaked havoc on the tab-carousel: the
         // view-pager moved twice as fast as it should because we called fakeDragBy()
         // twice with the same value.
         if (mLastScrollPosition == x) return;

         // Since we never completely scroll the about/updates tabs off-screen,
         // the draggable range is less than the width of the carousel. Our
         // listeners don't care about this... if we scroll 75% percent of our
         // draggable range, they want to scroll 75% of the entire carousel
         // width, not the same number of pixels that we scrolled.
         int scaledL = (int) (x * mScrollScaleFactor);
         int oldScaledL = (int) (oldX * mScrollScaleFactor);
         mListener.onScrollChanged(scaledL, y, oldScaledL, oldY);

         mLastScrollPosition = x;
         updateAlphaLayers();
     }

     /**
      * Reset the carousel to the start position (i.e. because new data will be loaded in for a
      * different contact).
      */
     public void reset() {
         scrollTo(0, 0);
         setCurrentTab(0);
         moveToYCoordinate(0, 0);
     }

     /**
      * Set the current tab that should be restored when the view is first laid out.
      */
     public void restoreCurrentTab(int position) {
         setCurrentTab(position);
         // It is only possible to scroll the view after onMeasure() has been called (where the
         // allowed horizontal scroll length is determined). Hence, set a flag that will be read
         // in onLayout() after the children and this view have finished being laid out.
         mScrollToCurrentTab = true;
     }

     /**
      * Restore the Y position of this view to the last manually requested value. This can be done
      * after the parent has been re-laid out again, where this view's position could have been
      * lost if the view laid outside its parent's bounds.
      */
     public void restoreYCoordinate() {
         setY(getStoredYCoordinateForTab(mCurrentTab));
     }

     /**
      * Request that the view move to the given Y coordinate. Also store the Y coordinate as the
      * last requested Y coordinate for the given tabIndex.
      */
     public void moveToYCoordinate(int tabIndex, float y) {
         setY(y);
         storeYCoordinate(tabIndex, y);
     }

     /**
      * Store this information as the last requested Y coordinate for the given tabIndex.
      */
     public void storeYCoordinate(int tabIndex, float y) {
         mYCoordinateArray[tabIndex] = y;
     }

     /**
      * Returns the stored Y coordinate of this view the last time the user was on the selected
      * tab given by tabIndex.
      */
     public float getStoredYCoordinateForTab(int tabIndex) {
         return mYCoordinateArray[tabIndex];
     }

     /**
      * Returns the number of pixels that this view can be scrolled horizontally.
      */
     public int getAllowedHorizontalScrollLength() {
         return mAllowedHorizontalScrollLength;
     }

     /**
      * Returns the number of pixels that this view can be scrolled vertically while still allowing
      * the tab labels to still show.
      */
     public int getAllowedVerticalScrollLength() {
         return mAllowedVerticalScrollLength;
     }

     /**
      * Updates the tab selection.
      */
     public void setCurrentTab(int position) {
         final CarouselTab selected, deselected;

         switch (position) {
             case TAB_INDEX_ABOUT:
                 selected = mAboutTab;
                 deselected = mUpdatesTab;
                 break;
             case TAB_INDEX_UPDATES:
                 selected = mUpdatesTab;
                 deselected = mAboutTab;
                 break;
             default:
                 throw new IllegalStateException("Invalid tab position " + position);
         }
         selected.showSelectedState();
         selected.setOverlayClickable(false);
         deselected.showDeselectedState();
         deselected.setOverlayClickable(true);
         mCurrentTab = position;
     }

     /**
      * Loads the data from the Loader-Result. This is the only function that has to be called
      * from the outside to fully setup the View
      */
     public void loadData(Contact contactData) {
         if (contactData == null) return;

         // TODO: Move this into the {@link CarouselTab} class when the updates
         // fragment code is more finalized.
         final boolean expandOnClick = contactData.getPhotoUri() != null;
         final OnClickListener listener = mPhotoSetter.setupContactPhotoForClick(
                 mContext, contactData, mPhotoView, expandOnClick);

         if (expandOnClick || contactData.isWritableContact(mContext)) {
             mPhotoViewOverlay.setOnClickListener(listener);
         } else {
             // Work around framework issue... if we instead use
             // setClickable(false), then we can't swipe horizontally.
             mPhotoViewOverlay.setOnClickListener(null);
         }

         ContactDetailDisplayUtils.setSocialSnippet(
                 mContext, contactData, mStatusView, mStatusPhotoView);
     }

     /**
      * Set the given {@link Listener} to handle carousel events.
      */
     public void setListener(Listener listener) {
         mListener = listener;
     }

     @Override
     public boolean onTouch(View v, MotionEvent event) {
         switch (event.getAction()) {
             case MotionEvent.ACTION_DOWN:
                 mListener.onTouchDown();
                 return true;
             case MotionEvent.ACTION_UP:
                 mListener.onTouchUp();
                 return true;
         }
         return super.onTouchEvent(event);
     }

     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         boolean interceptTouch = super.onInterceptTouchEvent(ev);
         if (interceptTouch) {
             mListener.onTouchDown();
         }
         return interceptTouch;
     }
 }
	/*
	* Copyright (C) 2011 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.contacts.detail;

	import android.content.Context;
	import android.content.res.Resources;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.util.TypedValue;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.View.OnTouchListener;
	import android.view.ViewPropertyAnimator;
	import android.widget.HorizontalScrollView;
	import android.widget.ImageView;
	import android.widget.TextView;

	import com.android.contacts.R;
	import com.android.contacts.model.Contact;
	import com.android.contacts.util.MoreMath;
	import com.android.contacts.util.SchedulingUtils;

	/**
	* This is a horizontally scrolling carousel with 2 tabs: one to see info about the contact and
	* one to see updates from the contact.
	*/
	public class ContactDetailTabCarousel extends HorizontalScrollView implements OnTouchListener {

	private static final String TAG = ContactDetailTabCarousel.class.getSimpleName();

	private static final int TRANSITION_TIME = 200;
	private static final int TRANSITION_MOVE_IN_TIME = 150;

	private static final int TAB_INDEX_ABOUT = 0;
	private static final int TAB_INDEX_UPDATES = 1;
	private static final int TAB_COUNT = 2;

	/** Tab width as defined as a fraction of the screen width */
	private float mTabWidthScreenWidthFraction;

	/** Tab height as defined as a fraction of the screen width */
	private float mTabHeightScreenWidthFraction;

	/** Height in pixels of the shadow under the tab carousel */
	private int mTabShadowHeight;

	private ImageView mPhotoView;
	private View mPhotoViewOverlay;
	private TextView mStatusView;
	private ImageView mStatusPhotoView;
	private final ContactDetailPhotoSetter mPhotoSetter = new ContactDetailPhotoSetter();

	private Listener mListener;

	private int mCurrentTab = TAB_INDEX_ABOUT;

	private View mTabAndShadowContainer;
	private View mShadow;
	private CarouselTab mAboutTab;
	private View mTabDivider;
	private CarouselTab mUpdatesTab;

	/** Last Y coordinate of the carousel when the tab at the given index was selected */
	private final float[] mYCoordinateArray = new float[TAB_COUNT];

	private int mTabDisplayLabelHeight;

	private boolean mScrollToCurrentTab = false;
	private int mLastScrollPosition = Integer.MIN_VALUE;
	private int mAllowedHorizontalScrollLength = Integer.MIN_VALUE;
	private int mAllowedVerticalScrollLength = Integer.MIN_VALUE;

	/** Factor to scale scroll-amount sent to listeners. */
	private float mScrollScaleFactor = 1.0f;

	private static final float MAX_ALPHA = 0.5f;

	/**
	* Interface for callbacks invoked when the user interacts with the carousel.
	*/
	public interface Listener {
	public void onTouchDown();
	public void onTouchUp();

	public void onScrollChanged(int l, int t, int oldl, int oldt);
	public void onTabSelected(int position);
	}

	public ContactDetailTabCarousel(Context context, AttributeSet attrs) {
	super(context, attrs);

	setOnTouchListener(this);

	Resources resources = mContext.getResources();
	mTabDisplayLabelHeight = resources.getDimensionPixelSize(
	R.dimen.detail_tab_carousel_tab_label_height);
	mTabShadowHeight = resources.getDimensionPixelSize(
	R.dimen.detail_contact_photo_shadow_height);
	mTabWidthScreenWidthFraction = resources.getFraction(
	R.fraction.tab_width_screen_width_percentage, 1, 1);
	mTabHeightScreenWidthFraction = resources.getFraction(
	R.fraction.tab_height_screen_width_percentage, 1, 1);
	}

	@Override
	protected void onFinishInflate() {
	super.onFinishInflate();
	mTabAndShadowContainer = findViewById(R.id.tab_and_shadow_container);
	mAboutTab = (CarouselTab) findViewById(R.id.tab_about);
	mAboutTab.setLabel(mContext.getString(R.string.contactDetailAbout));
	mAboutTab.setOverlayOnClickListener(mAboutTabTouchInterceptListener);

	mTabDivider = findViewById(R.id.tab_divider);

	mUpdatesTab = (CarouselTab) findViewById(R.id.tab_update);
	mUpdatesTab.setLabel(mContext.getString(R.string.contactDetailUpdates));
	mUpdatesTab.setOverlayOnClickListener(mUpdatesTabTouchInterceptListener);

	mShadow = findViewById(R.id.shadow);

	// Retrieve the photo view for the "about" tab
	// TODO: This should be moved down to mAboutTab, so that it hosts its own controls
	mPhotoView = (ImageView) mAboutTab.findViewById(R.id.photo);
	mPhotoViewOverlay = mAboutTab.findViewById(R.id.photo_overlay);

	// Retrieve the social update views for the "updates" tab
	// TODO: This should be moved down to mUpdatesTab, so that it hosts its own controls
	mStatusView = (TextView) mUpdatesTab.findViewById(R.id.status);
	mStatusPhotoView = (ImageView) mUpdatesTab.findViewById(R.id.status_photo);

	// Workaround for framework issue... it shouldn't be necessary to have a
	// clickable object in the hierarchy, but if not the horizontal scroll
	// behavior doesn't work. Note: the "About" tab doesn't need this
	// because we set a real click-handler elsewhere.
	mStatusView.setClickable(true);
	mStatusPhotoView.setClickable(true);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	int screenWidth = MeasureSpec.getSize(widthMeasureSpec);
	// Compute the width of a tab as a fraction of the screen width
	int tabWidth = Math.round(mTabWidthScreenWidthFraction * screenWidth);

	// Find the allowed scrolling length by subtracting the current visible screen width
	// from the total length of the tabs.
	mAllowedHorizontalScrollLength = tabWidth * TAB_COUNT - screenWidth;

	// Scrolling by mAllowedHorizontalScrollLength causes listeners to
	// scroll by the entire screen amount; compute the scale-factor
	// necessary to make this so.
	if (mAllowedHorizontalScrollLength == 0) {
	// Guard against divide-by-zero.
	// Note: this hard-coded value prevents a crash, but won't result in the
	// desired scrolling behavior. We rely on the framework calling onMeasure()
	// again with a non-zero screen width.
	mScrollScaleFactor = 1.0f;
	Log.w(TAG, "set scale-factor to 1.0 to avoid divide-by-zero");
	} else {
	mScrollScaleFactor = screenWidth / mAllowedHorizontalScrollLength;
	}

	int tabHeight = Math.round(screenWidth * mTabHeightScreenWidthFraction) + mTabShadowHeight;
	// Set the child {@link LinearLayout} to be TAB_COUNT * the computed tab width so that the
	// {@link LinearLayout}'s children (which are the tabs) will evenly split that width.
	if (getChildCount() > 0) {
	View child = getChildAt(0);

	// add 1 dip of separation between the tabs
	final int seperatorPixels =
	(int)(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1,
	getResources().getDisplayMetrics()) + 0.5f);

	child.measure(
	MeasureSpec.makeMeasureSpec(
	TAB_COUNT * tabWidth +
	(TAB_COUNT - 1) * seperatorPixels, MeasureSpec.EXACTLY),
	MeasureSpec.makeMeasureSpec(tabHeight, MeasureSpec.EXACTLY));
	}

	mAllowedVerticalScrollLength = tabHeight - mTabDisplayLabelHeight - mTabShadowHeight;
	setMeasuredDimension(
	resolveSize(screenWidth, widthMeasureSpec),
	resolveSize(tabHeight, heightMeasureSpec));
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	super.onLayout(changed, l, t, r, b);

	// Defer this stuff until after the layout has finished. This is because
	// updateAlphaLayers() ultimately results in another layout request, and
	// the framework currently can't handle this safely.
	if (!mScrollToCurrentTab) return;
	mScrollToCurrentTab = false;
	SchedulingUtils.doAfterLayout(this, new Runnable() {
	@Override
	public void run() {
	scrollTo(mCurrentTab == TAB_INDEX_ABOUT ? 0 : mAllowedHorizontalScrollLength, 0);
	updateAlphaLayers();
	}
	});
	}

	/** When clicked, selects the corresponding tab. */
	private class TabClickListener implements OnClickListener {
	private final int mTab;

	public TabClickListener(int tab) {
	super();
	mTab = tab;
	}

	@Override
	public void onClick(View v) {
	mListener.onTabSelected(mTab);
	}
	}

	private final TabClickListener mAboutTabTouchInterceptListener =
	new TabClickListener(TAB_INDEX_ABOUT);

	private final TabClickListener mUpdatesTabTouchInterceptListener =
	new TabClickListener(TAB_INDEX_UPDATES);

	/**
	* Does in "appear" animation to allow a seamless transition from
	* the "No updates" mode.
	* @param width Width of the container. As we haven't been layed out yet, we can't know
	* @param scrollOffset The offset by how far we scrolled, where 0=not scrolled, -x=scrolled by
	* x pixels, Integer.MIN_VALUE=scrolled so far that the image is not visible in "no updates"
	* mode of this screen
	*/
	public void animateAppear(int width, int scrollOffset) {
	final float photoHeight = mTabHeightScreenWidthFraction * width;
	final boolean animateZoomAndFade;
	int pixelsToScrollVertically = 0;

	// Depending on how far we are scrolled down, there is one of three animations:
	// - Zoom and fade the picture (if it is still visible)
	// - Scroll, zoom and fade (if the picture is mostly invisible and we now have a
	// bigger visible region due to the pinning)
	// - Just scroll if the picture is completely invisible. This time, no zoom is needed
	if (scrollOffset == Integer.MIN_VALUE) {
	// animate in completely by scrolling. no need for zooming here
	pixelsToScrollVertically = mTabDisplayLabelHeight;
	animateZoomAndFade = false;
	} else {
	final int pixelsOfPhotoLeft = Math.round(photoHeight) + scrollOffset;
	if (pixelsOfPhotoLeft > mTabDisplayLabelHeight) {
	// nothing to scroll
	pixelsToScrollVertically = 0;
	} else {
	pixelsToScrollVertically = mTabDisplayLabelHeight - pixelsOfPhotoLeft;
	}
	animateZoomAndFade = true;
	}

	if (pixelsToScrollVertically != 0) {
	// We can't animate ourselves here, because our own translation is needed for the user's
	// scrolling. Instead, we use our only child. As we are transparent, that is just as
	// good
	mTabAndShadowContainer.setTranslationY(-pixelsToScrollVertically);
	final ViewPropertyAnimator animator = mTabAndShadowContainer.animate();
	animator.translationY(0.0f);
	animator.setDuration(TRANSITION_MOVE_IN_TIME);
	}

	if (animateZoomAndFade) {
	// Hack: We have two types of possible layouts:
	// If the picture is square, it is square in both "with updates" and "without updates"
	// --> no need for scale animation here
	// example: 10inch tablet portrait
	// If the picture is non-square, it is full-width in "without updates" and something
	// arbitrary in "with updates"
	// --> do animation with container
	// example: 4.6inch phone portrait
	final boolean squarePicture =
	mTabWidthScreenWidthFraction == mTabHeightScreenWidthFraction;
	final int firstTransitionTime;
	if (squarePicture) {
	firstTransitionTime = 0;
	} else {
	// For x, we need to scale our container so we'll animate the whole tab
	// (unfortunately, we need to have the text invisible during this transition as it
	// would also be stretched)
	float revScale = 1.0f/mTabWidthScreenWidthFraction;
	mAboutTab.setScaleX(revScale);
	mAboutTab.setPivotX(0.0f);
	final ViewPropertyAnimator aboutAnimator = mAboutTab.animate();
	aboutAnimator.setDuration(TRANSITION_TIME);
	aboutAnimator.scaleX(1.0f);

	// For y, we need to scale only the picture itself because we want it to be cropped
	mPhotoView.setScaleY(revScale);
	mPhotoView.setPivotY(photoHeight * 0.5f);
	final ViewPropertyAnimator photoAnimator = mPhotoView.animate();
	photoAnimator.setDuration(TRANSITION_TIME);
	photoAnimator.scaleY(1.0f);
	firstTransitionTime = TRANSITION_TIME;
	}

	// Animate in the labels after the above transition is finished
	mAboutTab.fadeInLabelViewAnimator(firstTransitionTime, true);
	mUpdatesTab.fadeInLabelViewAnimator(firstTransitionTime, false);

	final float pixelsToTranslate = (1.0f - mTabWidthScreenWidthFraction) * width;
	// Views to translate
	for (View view : new View[] { mUpdatesTab, mTabDivider }) {
	view.setTranslationX(pixelsToTranslate);
	final ViewPropertyAnimator translateAnimator = view.animate();
	translateAnimator.translationX(0.0f);
	translateAnimator.setDuration(TRANSITION_TIME);
	}

	// Another hack: If the picture is square, there is no shadow in "Without updates"
	// --> fade it in after the translations are done
	if (squarePicture) {
	mShadow.setAlpha(0.0f);
	mShadow.animate().setStartDelay(TRANSITION_TIME).alpha(1.0f);
	}
	}
	}

	private void updateAlphaLayers() {
	float alpha = mLastScrollPosition * MAX_ALPHA / mAllowedHorizontalScrollLength;
	alpha = MoreMath.clamp(alpha, 0.0f, 1.0f);
	mAboutTab.setAlphaLayerValue(alpha);
	mUpdatesTab.setAlphaLayerValue(MAX_ALPHA - alpha);
	}

	@Override
	protected void onScrollChanged(int x, int y, int oldX, int oldY) {
	super.onScrollChanged(x, y, oldX, oldY);

	// Guard against framework issue where onScrollChanged() is called twice
	// for each touch-move event. This wreaked havoc on the tab-carousel: the
	// view-pager moved twice as fast as it should because we called fakeDragBy()
	// twice with the same value.
	if (mLastScrollPosition == x) return;

	// Since we never completely scroll the about/updates tabs off-screen,
	// the draggable range is less than the width of the carousel. Our
	// listeners don't care about this... if we scroll 75% percent of our
	// draggable range, they want to scroll 75% of the entire carousel
	// width, not the same number of pixels that we scrolled.
	int scaledL = (int) (x * mScrollScaleFactor);
	int oldScaledL = (int) (oldX * mScrollScaleFactor);
	mListener.onScrollChanged(scaledL, y, oldScaledL, oldY);

	mLastScrollPosition = x;
	updateAlphaLayers();
	}

	/**
	* Reset the carousel to the start position (i.e. because new data will be loaded in for a
	* different contact).
	*/
	public void reset() {
	scrollTo(0, 0);
	setCurrentTab(0);
	moveToYCoordinate(0, 0);
	}

	/**
	* Set the current tab that should be restored when the view is first laid out.
	*/
	public void restoreCurrentTab(int position) {
	setCurrentTab(position);
	// It is only possible to scroll the view after onMeasure() has been called (where the
	// allowed horizontal scroll length is determined). Hence, set a flag that will be read
	// in onLayout() after the children and this view have finished being laid out.
	mScrollToCurrentTab = true;
	}

	/**
	* Restore the Y position of this view to the last manually requested value. This can be done
	* after the parent has been re-laid out again, where this view's position could have been
	* lost if the view laid outside its parent's bounds.
	*/
	public void restoreYCoordinate() {
	setY(getStoredYCoordinateForTab(mCurrentTab));
	}

	/**
	* Request that the view move to the given Y coordinate. Also store the Y coordinate as the
	* last requested Y coordinate for the given tabIndex.
	*/
	public void moveToYCoordinate(int tabIndex, float y) {
	setY(y);
	storeYCoordinate(tabIndex, y);
	}

	/**
	* Store this information as the last requested Y coordinate for the given tabIndex.
	*/
	public void storeYCoordinate(int tabIndex, float y) {
	mYCoordinateArray[tabIndex] = y;
	}

	/**
	* Returns the stored Y coordinate of this view the last time the user was on the selected
	* tab given by tabIndex.
	*/
	public float getStoredYCoordinateForTab(int tabIndex) {
	return mYCoordinateArray[tabIndex];
	}

	/**
	* Returns the number of pixels that this view can be scrolled horizontally.
	*/
	public int getAllowedHorizontalScrollLength() {
	return mAllowedHorizontalScrollLength;
	}

	/**
	* Returns the number of pixels that this view can be scrolled vertically while still allowing
	* the tab labels to still show.
	*/
	public int getAllowedVerticalScrollLength() {
	return mAllowedVerticalScrollLength;
	}

	/**
	* Updates the tab selection.
	*/
	public void setCurrentTab(int position) {
	final CarouselTab selected, deselected;

	switch (position) {
	case TAB_INDEX_ABOUT:
	selected = mAboutTab;
	deselected = mUpdatesTab;
	break;
	case TAB_INDEX_UPDATES:
	selected = mUpdatesTab;
	deselected = mAboutTab;
	break;
	default:
	throw new IllegalStateException("Invalid tab position " + position);
	}
	selected.showSelectedState();
	selected.setOverlayClickable(false);
	deselected.showDeselectedState();
	deselected.setOverlayClickable(true);
	mCurrentTab = position;
	}

	/**
	* Loads the data from the Loader-Result. This is the only function that has to be called
	* from the outside to fully setup the View
	*/
	public void loadData(Contact contactData) {
	if (contactData == null) return;

	// TODO: Move this into the {@link CarouselTab} class when the updates
	// fragment code is more finalized.
	final boolean expandOnClick = contactData.getPhotoUri() != null;
	final OnClickListener listener = mPhotoSetter.setupContactPhotoForClick(
	mContext, contactData, mPhotoView, expandOnClick);

	if (expandOnClick \|\| contactData.isWritableContact(mContext)) {
	mPhotoViewOverlay.setOnClickListener(listener);
	} else {
	// Work around framework issue... if we instead use
	// setClickable(false), then we can't swipe horizontally.
	mPhotoViewOverlay.setOnClickListener(null);
	}

	ContactDetailDisplayUtils.setSocialSnippet(
	mContext, contactData, mStatusView, mStatusPhotoView);
	}

	/**
	* Set the given {@link Listener} to handle carousel events.
	*/
	public void setListener(Listener listener) {
	mListener = listener;
	}

	@Override
	public boolean onTouch(View v, MotionEvent event) {
	switch (event.getAction()) {
	case MotionEvent.ACTION_DOWN:
	mListener.onTouchDown();
	return true;
	case MotionEvent.ACTION_UP:
	mListener.onTouchUp();
	return true;
	}
	return super.onTouchEvent(event);
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent ev) {
	boolean interceptTouch = super.onInterceptTouchEvent(ev);
	if (interceptTouch) {
	mListener.onTouchDown();
	}
	return interceptTouch;
	}
	}