| /* |
| * Copyright (C) 2012 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.keyguard; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.ObjectAnimator; |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.content.res.TypedArray; |
| import android.graphics.Canvas; |
| import android.graphics.Paint; |
| import android.graphics.Rect; |
| import android.util.AttributeSet; |
| import android.util.DisplayMetrics; |
| import android.util.FloatProperty; |
| import android.util.Log; |
| import android.util.Property; |
| import android.view.MotionEvent; |
| import android.view.VelocityTracker; |
| import android.view.View; |
| import android.view.ViewConfiguration; |
| import android.view.ViewGroup; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.animation.Interpolator; |
| import android.widget.Scroller; |
| |
| /** |
| * This layout handles interaction with the sliding security challenge views |
| * that overlay/resize other keyguard contents. |
| */ |
| public class SlidingChallengeLayout extends ViewGroup implements ChallengeLayout { |
| private static final String TAG = "SlidingChallengeLayout"; |
| private static final boolean DEBUG = KeyguardConstants.DEBUG; |
| |
| // The drag handle is measured in dp above & below the top edge of the |
| // challenge view; these parameters change based on whether the challenge |
| // is open or closed. |
| private static final int DRAG_HANDLE_CLOSED_ABOVE = 8; // dp |
| private static final int DRAG_HANDLE_CLOSED_BELOW = 0; // dp |
| private static final int DRAG_HANDLE_OPEN_ABOVE = 8; // dp |
| private static final int DRAG_HANDLE_OPEN_BELOW = 0; // dp |
| |
| private static final int HANDLE_ANIMATE_DURATION = 250; // ms |
| |
| // Drawn to show the drag handle in closed state; crossfades to the challenge view |
| // when challenge is fully visible |
| private boolean mEdgeCaptured; |
| |
| private DisplayMetrics mDisplayMetrics; |
| |
| // Initialized during measurement from child layoutparams |
| private View mExpandChallengeView; |
| private KeyguardSecurityContainer mChallengeView; |
| private View mScrimView; |
| private View mWidgetsView; |
| |
| // Range: 0 (fully hidden) to 1 (fully visible) |
| private float mChallengeOffset = 1.f; |
| private boolean mChallengeShowing = true; |
| private boolean mChallengeShowingTargetState = true; |
| private boolean mWasChallengeShowing = true; |
| private boolean mIsBouncing = false; |
| |
| private final Scroller mScroller; |
| private ObjectAnimator mFader; |
| private int mScrollState; |
| private OnChallengeScrolledListener mScrollListener; |
| private OnBouncerStateChangedListener mBouncerListener; |
| private boolean mEnableChallengeDragging; |
| |
| public static final int SCROLL_STATE_IDLE = 0; |
| public static final int SCROLL_STATE_DRAGGING = 1; |
| public static final int SCROLL_STATE_SETTLING = 2; |
| public static final int SCROLL_STATE_FADING = 3; |
| |
| public static final int CHALLENGE_FADE_OUT_DURATION = 100; |
| public static final int CHALLENGE_FADE_IN_DURATION = 160; |
| |
| private static final int MAX_SETTLE_DURATION = 600; // ms |
| |
| // ID of the pointer in charge of a current drag |
| private int mActivePointerId = INVALID_POINTER; |
| private static final int INVALID_POINTER = -1; |
| |
| // True if the user is currently dragging the slider |
| private boolean mDragging; |
| // True if the user may not drag until a new gesture begins |
| private boolean mBlockDrag; |
| |
| private VelocityTracker mVelocityTracker; |
| private int mMinVelocity; |
| private int mMaxVelocity; |
| private float mGestureStartX, mGestureStartY; // where did you first touch the screen? |
| private int mGestureStartChallengeBottom; // where was the challenge at that time? |
| |
| private int mDragHandleClosedBelow; // handle hitrect extension into the challenge view |
| private int mDragHandleClosedAbove; // extend the handle's hitrect this far above the line |
| private int mDragHandleOpenBelow; // handle hitrect extension into the challenge view |
| private int mDragHandleOpenAbove; // extend the handle's hitrect this far above the line |
| |
| private int mDragHandleEdgeSlop; |
| private int mChallengeBottomBound; // Number of pixels from the top of the challenge view |
| // that should remain on-screen |
| |
| private int mTouchSlop; |
| private int mTouchSlopSquare; |
| |
| float mHandleAlpha; |
| float mFrameAlpha; |
| float mFrameAnimationTarget = Float.MIN_VALUE; |
| private ObjectAnimator mHandleAnimation; |
| private ObjectAnimator mFrameAnimation; |
| |
| private boolean mHasGlowpad; |
| private final Rect mInsets = new Rect(); |
| |
| // We have an internal and external version, and we and them together. |
| private boolean mChallengeInteractiveExternal = true; |
| private boolean mChallengeInteractiveInternal = true; |
| |
| static final Property<SlidingChallengeLayout, Float> HANDLE_ALPHA = |
| new FloatProperty<SlidingChallengeLayout>("handleAlpha") { |
| @Override |
| public void setValue(SlidingChallengeLayout view, float value) { |
| view.mHandleAlpha = value; |
| view.invalidate(); |
| } |
| |
| @Override |
| public Float get(SlidingChallengeLayout view) { |
| return view.mHandleAlpha; |
| } |
| }; |
| |
| // True if at least one layout pass has happened since the view was attached. |
| private boolean mHasLayout; |
| |
| private static final Interpolator sMotionInterpolator = new Interpolator() { |
| public float getInterpolation(float t) { |
| t -= 1.0f; |
| return t * t * t * t * t + 1.0f; |
| } |
| }; |
| |
| private static final Interpolator sHandleFadeInterpolator = new Interpolator() { |
| public float getInterpolation(float t) { |
| return t * t; |
| } |
| }; |
| |
| private final Runnable mEndScrollRunnable = new Runnable () { |
| public void run() { |
| completeChallengeScroll(); |
| } |
| }; |
| |
| private final OnClickListener mScrimClickListener = new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| hideBouncer(); |
| } |
| }; |
| |
| private final OnClickListener mExpandChallengeClickListener = new OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| if (!isChallengeShowing()) { |
| showChallenge(true); |
| } |
| } |
| }; |
| |
| /** |
| * Listener interface that reports changes in scroll state of the challenge area. |
| */ |
| public interface OnChallengeScrolledListener { |
| /** |
| * The scroll state itself changed. |
| * |
| * <p>scrollState will be one of the following:</p> |
| * |
| * <ul> |
| * <li><code>SCROLL_STATE_IDLE</code> - The challenge area is stationary.</li> |
| * <li><code>SCROLL_STATE_DRAGGING</code> - The user is actively dragging |
| * the challenge area.</li> |
| * <li><code>SCROLL_STATE_SETTLING</code> - The challenge area is animating |
| * into place.</li> |
| * </ul> |
| * |
| * <p>Do not perform expensive operations (e.g. layout) |
| * while the scroll state is not <code>SCROLL_STATE_IDLE</code>.</p> |
| * |
| * @param scrollState The new scroll state of the challenge area. |
| */ |
| public void onScrollStateChanged(int scrollState); |
| |
| /** |
| * The precise position of the challenge area has changed. |
| * |
| * <p>NOTE: It is NOT safe to modify layout or call any View methods that may |
| * result in a requestLayout anywhere in your view hierarchy as a result of this call. |
| * It may be called during drawing.</p> |
| * |
| * @param scrollPosition New relative position of the challenge area. |
| * 1.f = fully visible/ready to be interacted with. |
| * 0.f = fully invisible/inaccessible to the user. |
| * @param challengeTop Position of the top edge of the challenge view in px in the |
| * SlidingChallengeLayout's coordinate system. |
| */ |
| public void onScrollPositionChanged(float scrollPosition, int challengeTop); |
| } |
| |
| public SlidingChallengeLayout(Context context) { |
| this(context, null); |
| } |
| |
| public SlidingChallengeLayout(Context context, AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public SlidingChallengeLayout(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| |
| mScroller = new Scroller(context, sMotionInterpolator); |
| |
| final ViewConfiguration vc = ViewConfiguration.get(context); |
| mMinVelocity = vc.getScaledMinimumFlingVelocity(); |
| mMaxVelocity = vc.getScaledMaximumFlingVelocity(); |
| |
| final Resources res = getResources(); |
| mDragHandleEdgeSlop = res.getDimensionPixelSize(R.dimen.kg_edge_swipe_region_size); |
| |
| mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop(); |
| mTouchSlopSquare = mTouchSlop * mTouchSlop; |
| |
| mDisplayMetrics = res.getDisplayMetrics(); |
| final float density = mDisplayMetrics.density; |
| |
| // top half of the lock icon, plus another 25% to be sure |
| mDragHandleClosedAbove = (int) (DRAG_HANDLE_CLOSED_ABOVE * density + 0.5f); |
| mDragHandleClosedBelow = (int) (DRAG_HANDLE_CLOSED_BELOW * density + 0.5f); |
| mDragHandleOpenAbove = (int) (DRAG_HANDLE_OPEN_ABOVE * density + 0.5f); |
| mDragHandleOpenBelow = (int) (DRAG_HANDLE_OPEN_BELOW * density + 0.5f); |
| |
| // how much space to account for in the handle when closed |
| mChallengeBottomBound = res.getDimensionPixelSize(R.dimen.kg_widget_pager_bottom_padding); |
| |
| setWillNotDraw(false); |
| setSystemUiVisibility(SYSTEM_UI_FLAG_LAYOUT_STABLE | SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION); |
| } |
| |
| public void setEnableChallengeDragging(boolean enabled) { |
| mEnableChallengeDragging = enabled; |
| } |
| |
| public void setInsets(Rect insets) { |
| mInsets.set(insets); |
| } |
| |
| public void setHandleAlpha(float alpha) { |
| if (mExpandChallengeView != null) { |
| mExpandChallengeView.setAlpha(alpha); |
| } |
| } |
| |
| public void setChallengeInteractive(boolean interactive) { |
| mChallengeInteractiveExternal = interactive; |
| if (mExpandChallengeView != null) { |
| mExpandChallengeView.setEnabled(interactive); |
| } |
| } |
| |
| void animateHandle(boolean visible) { |
| if (mHandleAnimation != null) { |
| mHandleAnimation.cancel(); |
| mHandleAnimation = null; |
| } |
| final float targetAlpha = visible ? 1.f : 0.f; |
| if (targetAlpha == mHandleAlpha) { |
| return; |
| } |
| mHandleAnimation = ObjectAnimator.ofFloat(this, HANDLE_ALPHA, targetAlpha); |
| mHandleAnimation.setInterpolator(sHandleFadeInterpolator); |
| mHandleAnimation.setDuration(HANDLE_ANIMATE_DURATION); |
| mHandleAnimation.start(); |
| } |
| |
| private void sendInitialListenerUpdates() { |
| if (mScrollListener != null) { |
| int challengeTop = mChallengeView != null ? mChallengeView.getTop() : 0; |
| mScrollListener.onScrollPositionChanged(mChallengeOffset, challengeTop); |
| mScrollListener.onScrollStateChanged(mScrollState); |
| } |
| } |
| |
| public void setOnChallengeScrolledListener(OnChallengeScrolledListener listener) { |
| mScrollListener = listener; |
| if (mHasLayout) { |
| sendInitialListenerUpdates(); |
| } |
| } |
| |
| public void setOnBouncerStateChangedListener(OnBouncerStateChangedListener listener) { |
| mBouncerListener = listener; |
| } |
| |
| @Override |
| public void onAttachedToWindow() { |
| super.onAttachedToWindow(); |
| |
| mHasLayout = false; |
| } |
| |
| @Override |
| public void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| |
| removeCallbacks(mEndScrollRunnable); |
| mHasLayout = false; |
| } |
| |
| @Override |
| public void requestChildFocus(View child, View focused) { |
| if (mIsBouncing && child != mChallengeView) { |
| // Clear out of the bouncer if the user tries to move focus outside of |
| // the security challenge view. |
| hideBouncer(); |
| } |
| super.requestChildFocus(child, focused); |
| } |
| |
| // We want the duration of the page snap animation to be influenced by the distance that |
| // the screen has to travel, however, we don't want this duration to be effected in a |
| // purely linear fashion. Instead, we use this method to moderate the effect that the distance |
| // of travel has on the overall snap duration. |
| float distanceInfluenceForSnapDuration(float f) { |
| f -= 0.5f; // center the values about 0. |
| f *= 0.3f * Math.PI / 2.0f; |
| return (float) Math.sin(f); |
| } |
| |
| void setScrollState(int state) { |
| if (mScrollState != state) { |
| mScrollState = state; |
| |
| animateHandle(state == SCROLL_STATE_IDLE && !mChallengeShowing); |
| if (mScrollListener != null) { |
| mScrollListener.onScrollStateChanged(state); |
| } |
| } |
| } |
| |
| void completeChallengeScroll() { |
| setChallengeShowing(mChallengeShowingTargetState); |
| mChallengeOffset = mChallengeShowing ? 1.f : 0.f; |
| setScrollState(SCROLL_STATE_IDLE); |
| mChallengeInteractiveInternal = true; |
| mChallengeView.setLayerType(LAYER_TYPE_NONE, null); |
| } |
| |
| void setScrimView(View scrim) { |
| if (mScrimView != null) { |
| mScrimView.setOnClickListener(null); |
| } |
| mScrimView = scrim; |
| if (mScrimView != null) { |
| mScrimView.setVisibility(mIsBouncing ? VISIBLE : GONE); |
| mScrimView.setFocusable(true); |
| mScrimView.setOnClickListener(mScrimClickListener); |
| } |
| } |
| |
| /** |
| * Animate the bottom edge of the challenge view to the given position. |
| * |
| * @param y desired final position for the bottom edge of the challenge view in px |
| * @param velocity velocity in |
| */ |
| void animateChallengeTo(int y, int velocity) { |
| if (mChallengeView == null) { |
| // Nothing to do. |
| return; |
| } |
| |
| cancelTransitionsInProgress(); |
| |
| mChallengeInteractiveInternal = false; |
| enableHardwareLayerForChallengeView(); |
| final int sy = mChallengeView.getBottom(); |
| final int dy = y - sy; |
| if (dy == 0) { |
| completeChallengeScroll(); |
| return; |
| } |
| |
| setScrollState(SCROLL_STATE_SETTLING); |
| |
| final int childHeight = mChallengeView.getHeight(); |
| final int halfHeight = childHeight / 2; |
| final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dy) / childHeight); |
| final float distance = halfHeight + halfHeight * |
| distanceInfluenceForSnapDuration(distanceRatio); |
| |
| int duration = 0; |
| velocity = Math.abs(velocity); |
| if (velocity > 0) { |
| duration = 4 * Math.round(1000 * Math.abs(distance / velocity)); |
| } else { |
| final float childDelta = (float) Math.abs(dy) / childHeight; |
| duration = (int) ((childDelta + 1) * 100); |
| } |
| duration = Math.min(duration, MAX_SETTLE_DURATION); |
| |
| mScroller.startScroll(0, sy, 0, dy, duration); |
| postInvalidateOnAnimation(); |
| } |
| |
| private void setChallengeShowing(boolean showChallenge) { |
| if (mChallengeShowing == showChallenge) { |
| return; |
| } |
| mChallengeShowing = showChallenge; |
| |
| if (mExpandChallengeView == null || mChallengeView == null) { |
| // These might not be here yet if we haven't been through layout. |
| // If we haven't, the first layout pass will set everything up correctly |
| // based on mChallengeShowing as set above. |
| return; |
| } |
| |
| if (mChallengeShowing) { |
| mExpandChallengeView.setVisibility(View.INVISIBLE); |
| mChallengeView.setVisibility(View.VISIBLE); |
| if (AccessibilityManager.getInstance(mContext).isEnabled()) { |
| mChallengeView.requestAccessibilityFocus(); |
| mChallengeView.announceForAccessibility(mContext.getString( |
| R.string.keyguard_accessibility_unlock_area_expanded)); |
| } |
| } else { |
| mExpandChallengeView.setVisibility(View.VISIBLE); |
| mChallengeView.setVisibility(View.INVISIBLE); |
| if (AccessibilityManager.getInstance(mContext).isEnabled()) { |
| mExpandChallengeView.requestAccessibilityFocus(); |
| mChallengeView.announceForAccessibility(mContext.getString( |
| R.string.keyguard_accessibility_unlock_area_collapsed)); |
| } |
| } |
| } |
| |
| /** |
| * @return true if the challenge is at all visible. |
| */ |
| public boolean isChallengeShowing() { |
| return mChallengeShowing; |
| } |
| |
| @Override |
| public boolean isChallengeOverlapping() { |
| return mChallengeShowing; |
| } |
| |
| @Override |
| public boolean isBouncing() { |
| return mIsBouncing; |
| } |
| |
| @Override |
| public int getBouncerAnimationDuration() { |
| return HANDLE_ANIMATE_DURATION; |
| } |
| |
| @Override |
| public void showBouncer() { |
| if (mIsBouncing) return; |
| setSystemUiVisibility(getSystemUiVisibility() | STATUS_BAR_DISABLE_SEARCH); |
| mWasChallengeShowing = mChallengeShowing; |
| mIsBouncing = true; |
| showChallenge(true); |
| if (mScrimView != null) { |
| Animator anim = ObjectAnimator.ofFloat(mScrimView, "alpha", 1f); |
| anim.setDuration(HANDLE_ANIMATE_DURATION); |
| anim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| mScrimView.setVisibility(VISIBLE); |
| } |
| }); |
| anim.start(); |
| } |
| if (mChallengeView != null) { |
| mChallengeView.showBouncer(HANDLE_ANIMATE_DURATION); |
| } |
| |
| if (mBouncerListener != null) { |
| mBouncerListener.onBouncerStateChanged(true); |
| } |
| } |
| |
| @Override |
| public void hideBouncer() { |
| if (!mIsBouncing) return; |
| setSystemUiVisibility(getSystemUiVisibility() & ~STATUS_BAR_DISABLE_SEARCH); |
| if (!mWasChallengeShowing) showChallenge(false); |
| mIsBouncing = false; |
| |
| if (mScrimView != null) { |
| Animator anim = ObjectAnimator.ofFloat(mScrimView, "alpha", 0f); |
| anim.setDuration(HANDLE_ANIMATE_DURATION); |
| anim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mScrimView.setVisibility(GONE); |
| } |
| }); |
| anim.start(); |
| } |
| if (mChallengeView != null) { |
| mChallengeView.hideBouncer(HANDLE_ANIMATE_DURATION); |
| } |
| if (mBouncerListener != null) { |
| mBouncerListener.onBouncerStateChanged(false); |
| } |
| } |
| |
| private int getChallengeMargin(boolean expanded) { |
| return expanded && mHasGlowpad ? 0 : mDragHandleEdgeSlop; |
| } |
| |
| private float getChallengeAlpha() { |
| float x = mChallengeOffset - 1; |
| return x * x * x + 1.f; |
| } |
| |
| @Override |
| public void requestDisallowInterceptTouchEvent(boolean allowIntercept) { |
| // We'll intercept whoever we feel like! ...as long as it isn't a challenge view. |
| // If there are one or more pointers in the challenge view before we take over |
| // touch events, onInterceptTouchEvent will set mBlockDrag. |
| } |
| |
| @Override |
| public boolean onInterceptTouchEvent(MotionEvent ev) { |
| if (mVelocityTracker == null) { |
| mVelocityTracker = VelocityTracker.obtain(); |
| } |
| mVelocityTracker.addMovement(ev); |
| |
| final int action = ev.getActionMasked(); |
| switch (action) { |
| case MotionEvent.ACTION_DOWN: |
| mGestureStartX = ev.getX(); |
| mGestureStartY = ev.getY(); |
| mBlockDrag = false; |
| break; |
| |
| case MotionEvent.ACTION_CANCEL: |
| case MotionEvent.ACTION_UP: |
| resetTouch(); |
| break; |
| |
| case MotionEvent.ACTION_MOVE: |
| final int count = ev.getPointerCount(); |
| for (int i = 0; i < count; i++) { |
| final float x = ev.getX(i); |
| final float y = ev.getY(i); |
| if (!mIsBouncing && mActivePointerId == INVALID_POINTER |
| && (crossedDragHandle(x, y, mGestureStartY) |
| && shouldEnableChallengeDragging() |
| || (isInChallengeView(x, y) && |
| mScrollState == SCROLL_STATE_SETTLING))) { |
| mActivePointerId = ev.getPointerId(i); |
| mGestureStartX = x; |
| mGestureStartY = y; |
| mGestureStartChallengeBottom = getChallengeBottom(); |
| mDragging = true; |
| enableHardwareLayerForChallengeView(); |
| } else if (mChallengeShowing && isInChallengeView(x, y) |
| && shouldEnableChallengeDragging()) { |
| mBlockDrag = true; |
| } |
| } |
| break; |
| } |
| |
| if (mBlockDrag || isChallengeInteractionBlocked()) { |
| mActivePointerId = INVALID_POINTER; |
| mDragging = false; |
| } |
| |
| return mDragging; |
| } |
| |
| private boolean shouldEnableChallengeDragging() { |
| return mEnableChallengeDragging || !mChallengeShowing; |
| } |
| |
| private boolean isChallengeInteractionBlocked() { |
| return !mChallengeInteractiveExternal || !mChallengeInteractiveInternal; |
| } |
| |
| private void resetTouch() { |
| mVelocityTracker.recycle(); |
| mVelocityTracker = null; |
| mActivePointerId = INVALID_POINTER; |
| mDragging = mBlockDrag = false; |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent ev) { |
| if (mVelocityTracker == null) { |
| mVelocityTracker = VelocityTracker.obtain(); |
| } |
| mVelocityTracker.addMovement(ev); |
| |
| final int action = ev.getActionMasked(); |
| switch (action) { |
| case MotionEvent.ACTION_DOWN: |
| mBlockDrag = false; |
| mGestureStartX = ev.getX(); |
| mGestureStartY = ev.getY(); |
| break; |
| |
| case MotionEvent.ACTION_CANCEL: |
| if (mDragging && !isChallengeInteractionBlocked()) { |
| showChallenge(0); |
| } |
| resetTouch(); |
| break; |
| |
| case MotionEvent.ACTION_POINTER_UP: |
| if (mActivePointerId != ev.getPointerId(ev.getActionIndex())) { |
| break; |
| } |
| case MotionEvent.ACTION_UP: |
| if (mDragging && !isChallengeInteractionBlocked()) { |
| mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity); |
| showChallenge((int) mVelocityTracker.getYVelocity(mActivePointerId)); |
| } |
| resetTouch(); |
| break; |
| |
| case MotionEvent.ACTION_MOVE: |
| if (!mDragging && !mBlockDrag && !mIsBouncing) { |
| final int count = ev.getPointerCount(); |
| for (int i = 0; i < count; i++) { |
| final float x = ev.getX(i); |
| final float y = ev.getY(i); |
| |
| if ((isInDragHandle(x, y) || crossedDragHandle(x, y, mGestureStartY) || |
| (isInChallengeView(x, y) && mScrollState == SCROLL_STATE_SETTLING)) |
| && mActivePointerId == INVALID_POINTER |
| && !isChallengeInteractionBlocked()) { |
| mGestureStartX = x; |
| mGestureStartY = y; |
| mActivePointerId = ev.getPointerId(i); |
| mGestureStartChallengeBottom = getChallengeBottom(); |
| mDragging = true; |
| enableHardwareLayerForChallengeView(); |
| break; |
| } |
| } |
| } |
| // Not an else; this can be set above. |
| if (mDragging) { |
| // No-op if already in this state, but set it here in case we arrived |
| // at this point from either intercept or the above. |
| setScrollState(SCROLL_STATE_DRAGGING); |
| |
| final int index = ev.findPointerIndex(mActivePointerId); |
| if (index < 0) { |
| // Oops, bogus state. We lost some touch events somewhere. |
| // Just drop it with no velocity and let things settle. |
| resetTouch(); |
| showChallenge(0); |
| return true; |
| } |
| final float y = ev.getY(index); |
| final float pos = Math.min(y - mGestureStartY, |
| getLayoutBottom() - mChallengeBottomBound); |
| |
| moveChallengeTo(mGestureStartChallengeBottom + (int) pos); |
| } |
| break; |
| } |
| return true; |
| } |
| |
| /** |
| * The lifecycle of touch events is subtle and it's very easy to do something |
| * that will cause bugs that will be nasty to track when overriding this method. |
| * Normally one should always override onInterceptTouchEvent instead. |
| * |
| * To put it another way, don't try this at home. |
| */ |
| @Override |
| public boolean dispatchTouchEvent(MotionEvent ev) { |
| final int action = ev.getActionMasked(); |
| boolean handled = false; |
| if (action == MotionEvent.ACTION_DOWN) { |
| // Defensive programming: if we didn't get the UP or CANCEL, reset anyway. |
| mEdgeCaptured = false; |
| } |
| if (mWidgetsView != null && !mIsBouncing && (mEdgeCaptured || isEdgeSwipeBeginEvent(ev))) { |
| // Normally we would need to do a lot of extra stuff here. |
| // We can only get away with this because we haven't padded in |
| // the widget pager or otherwise transformed it during layout. |
| // We also don't support things like splitting MotionEvents. |
| |
| // We set handled to captured even if dispatch is returning false here so that |
| // we don't send a different view a busted or incomplete event stream. |
| handled = mEdgeCaptured |= mWidgetsView.dispatchTouchEvent(ev); |
| } |
| |
| if (!handled && !mEdgeCaptured) { |
| handled = super.dispatchTouchEvent(ev); |
| } |
| |
| if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) { |
| mEdgeCaptured = false; |
| } |
| |
| return handled; |
| } |
| |
| private boolean isEdgeSwipeBeginEvent(MotionEvent ev) { |
| if (ev.getActionMasked() != MotionEvent.ACTION_DOWN) { |
| return false; |
| } |
| |
| final float x = ev.getX(); |
| return x < mDragHandleEdgeSlop || x >= getWidth() - mDragHandleEdgeSlop; |
| } |
| |
| /** |
| * We only want to add additional vertical space to the drag handle when the panel is fully |
| * closed. |
| */ |
| private int getDragHandleSizeAbove() { |
| return isChallengeShowing() ? mDragHandleOpenAbove : mDragHandleClosedAbove; |
| } |
| private int getDragHandleSizeBelow() { |
| return isChallengeShowing() ? mDragHandleOpenBelow : mDragHandleClosedBelow; |
| } |
| |
| private boolean isInChallengeView(float x, float y) { |
| return isPointInView(x, y, mChallengeView); |
| } |
| |
| private boolean isInDragHandle(float x, float y) { |
| return isPointInView(x, y, mExpandChallengeView); |
| } |
| |
| private boolean isPointInView(float x, float y, View view) { |
| if (view == null) { |
| return false; |
| } |
| return x >= view.getLeft() && y >= view.getTop() |
| && x < view.getRight() && y < view.getBottom(); |
| } |
| |
| private boolean crossedDragHandle(float x, float y, float initialY) { |
| |
| final int challengeTop = mChallengeView.getTop(); |
| final boolean horizOk = x >= 0 && x < getWidth(); |
| |
| final boolean vertOk; |
| if (mChallengeShowing) { |
| vertOk = initialY < (challengeTop - getDragHandleSizeAbove()) && |
| y > challengeTop + getDragHandleSizeBelow(); |
| } else { |
| vertOk = initialY > challengeTop + getDragHandleSizeBelow() && |
| y < challengeTop - getDragHandleSizeAbove(); |
| } |
| return horizOk && vertOk; |
| } |
| |
| private int makeChildMeasureSpec(int maxSize, int childDimen) { |
| final int mode; |
| final int size; |
| switch (childDimen) { |
| case LayoutParams.WRAP_CONTENT: |
| mode = MeasureSpec.AT_MOST; |
| size = maxSize; |
| break; |
| case LayoutParams.MATCH_PARENT: |
| mode = MeasureSpec.EXACTLY; |
| size = maxSize; |
| break; |
| default: |
| mode = MeasureSpec.EXACTLY; |
| size = Math.min(maxSize, childDimen); |
| break; |
| } |
| return MeasureSpec.makeMeasureSpec(size, mode); |
| } |
| |
| @Override |
| protected void onMeasure(int widthSpec, int heightSpec) { |
| if (MeasureSpec.getMode(widthSpec) != MeasureSpec.EXACTLY || |
| MeasureSpec.getMode(heightSpec) != MeasureSpec.EXACTLY) { |
| throw new IllegalArgumentException( |
| "SlidingChallengeLayout must be measured with an exact size"); |
| } |
| final int width = MeasureSpec.getSize(widthSpec); |
| final int height = MeasureSpec.getSize(heightSpec); |
| setMeasuredDimension(width, height); |
| |
| final int insetHeight = height - mInsets.top - mInsets.bottom; |
| final int insetHeightSpec = MeasureSpec.makeMeasureSpec(insetHeight, MeasureSpec.EXACTLY); |
| |
| // Find one and only one challenge view. |
| final View oldChallengeView = mChallengeView; |
| final View oldExpandChallengeView = mChallengeView; |
| mChallengeView = null; |
| mExpandChallengeView = null; |
| final int count = getChildCount(); |
| |
| // First iteration through the children finds special children and sets any associated |
| // state. |
| for (int i = 0; i < count; i++) { |
| final View child = getChildAt(i); |
| final LayoutParams lp = (LayoutParams) child.getLayoutParams(); |
| if (lp.childType == LayoutParams.CHILD_TYPE_CHALLENGE) { |
| if (mChallengeView != null) { |
| throw new IllegalStateException( |
| "There may only be one child with layout_isChallenge=\"true\""); |
| } |
| if (!(child instanceof KeyguardSecurityContainer)) { |
| throw new IllegalArgumentException( |
| "Challenge must be a KeyguardSecurityContainer"); |
| } |
| mChallengeView = (KeyguardSecurityContainer) child; |
| if (mChallengeView != oldChallengeView) { |
| mChallengeView.setVisibility(mChallengeShowing ? VISIBLE : INVISIBLE); |
| } |
| // We're going to play silly games with the frame's background drawable later. |
| if (!mHasLayout) { |
| // Set up the margin correctly based on our content for the first run. |
| mHasGlowpad = child.findViewById(R.id.keyguard_selector_view) != null; |
| lp.leftMargin = lp.rightMargin = getChallengeMargin(true); |
| } |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_EXPAND_CHALLENGE_HANDLE) { |
| if (mExpandChallengeView != null) { |
| throw new IllegalStateException( |
| "There may only be one child with layout_childType" |
| + "=\"expandChallengeHandle\""); |
| } |
| mExpandChallengeView = child; |
| if (mExpandChallengeView != oldExpandChallengeView) { |
| mExpandChallengeView.setVisibility(mChallengeShowing ? INVISIBLE : VISIBLE); |
| mExpandChallengeView.setOnClickListener(mExpandChallengeClickListener); |
| } |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_SCRIM) { |
| setScrimView(child); |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_WIDGETS) { |
| mWidgetsView = child; |
| } |
| } |
| |
| // We want to measure the challenge view first, since the KeyguardWidgetPager |
| // needs to do things its measure pass that are dependent on the challenge view |
| // having been measured. |
| if (mChallengeView != null && mChallengeView.getVisibility() != View.GONE) { |
| // This one's a little funny. If the IME is present - reported in the form |
| // of insets on the root view - we only give the challenge the space it would |
| // have had if the IME wasn't there in order to keep the rest of the layout stable. |
| // We base this on the layout_maxHeight on the challenge view. If it comes out |
| // negative or zero, either we didn't have a maxHeight or we're totally out of space, |
| // so give up and measure as if this rule weren't there. |
| int challengeHeightSpec = insetHeightSpec; |
| final View root = getRootView(); |
| if (root != null) { |
| final LayoutParams lp = (LayoutParams) mChallengeView.getLayoutParams(); |
| final int windowHeight = mDisplayMetrics.heightPixels |
| - root.getPaddingTop() - mInsets.top; |
| final int diff = windowHeight - insetHeight; |
| final int maxChallengeHeight = lp.maxHeight - diff; |
| if (maxChallengeHeight > 0) { |
| challengeHeightSpec = makeChildMeasureSpec(maxChallengeHeight, lp.height); |
| } |
| } |
| measureChildWithMargins(mChallengeView, widthSpec, 0, challengeHeightSpec, 0); |
| } |
| |
| // Measure the rest of the children |
| for (int i = 0; i < count; i++) { |
| final View child = getChildAt(i); |
| if (child.getVisibility() == GONE) { |
| continue; |
| } |
| // Don't measure the challenge view twice! |
| if (child == mChallengeView) continue; |
| |
| // Measure children. Widget frame measures special, so that we can ignore |
| // insets for the IME. |
| int parentWidthSpec = widthSpec, parentHeightSpec = insetHeightSpec; |
| final LayoutParams lp = (LayoutParams) child.getLayoutParams(); |
| if (lp.childType == LayoutParams.CHILD_TYPE_WIDGETS) { |
| final View root = getRootView(); |
| if (root != null) { |
| // This calculation is super dodgy and relies on several assumptions. |
| // Specifically that the root of the window will be padded in for insets |
| // and that the window is LAYOUT_IN_SCREEN. |
| final int windowWidth = mDisplayMetrics.widthPixels; |
| final int windowHeight = mDisplayMetrics.heightPixels |
| - root.getPaddingTop() - mInsets.top; |
| parentWidthSpec = MeasureSpec.makeMeasureSpec( |
| windowWidth, MeasureSpec.EXACTLY); |
| parentHeightSpec = MeasureSpec.makeMeasureSpec( |
| windowHeight, MeasureSpec.EXACTLY); |
| } |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_SCRIM) { |
| // Allow scrim views to extend into the insets |
| parentWidthSpec = widthSpec; |
| parentHeightSpec = heightSpec; |
| } |
| measureChildWithMargins(child, parentWidthSpec, 0, parentHeightSpec, 0); |
| } |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int l, int t, int r, int b) { |
| final int paddingLeft = getPaddingLeft(); |
| final int paddingTop = getPaddingTop(); |
| final int paddingRight = getPaddingRight(); |
| final int paddingBottom = getPaddingBottom(); |
| final int width = r - l; |
| final int height = b - t; |
| |
| final int count = getChildCount(); |
| for (int i = 0; i < count; i++) { |
| final View child = getChildAt(i); |
| |
| if (child.getVisibility() == GONE) continue; |
| |
| final LayoutParams lp = (LayoutParams) child.getLayoutParams(); |
| |
| if (lp.childType == LayoutParams.CHILD_TYPE_CHALLENGE) { |
| // Challenge views pin to the bottom, offset by a portion of their height, |
| // and center horizontally. |
| final int center = (paddingLeft + width - paddingRight) / 2; |
| final int childWidth = child.getMeasuredWidth(); |
| final int childHeight = child.getMeasuredHeight(); |
| final int left = center - childWidth / 2; |
| final int layoutBottom = height - paddingBottom - lp.bottomMargin - mInsets.bottom; |
| // We use the top of the challenge view to position the handle, so |
| // we never want less than the handle size showing at the bottom. |
| final int bottom = layoutBottom + (int) ((childHeight - mChallengeBottomBound) |
| * (1 - mChallengeOffset)); |
| child.setAlpha(getChallengeAlpha()); |
| child.layout(left, bottom - childHeight, left + childWidth, bottom); |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_EXPAND_CHALLENGE_HANDLE) { |
| final int center = (paddingLeft + width - paddingRight) / 2; |
| final int left = center - child.getMeasuredWidth() / 2; |
| final int right = left + child.getMeasuredWidth(); |
| final int bottom = height - paddingBottom - lp.bottomMargin - mInsets.bottom; |
| final int top = bottom - child.getMeasuredHeight(); |
| child.layout(left, top, right, bottom); |
| } else if (lp.childType == LayoutParams.CHILD_TYPE_SCRIM) { |
| // Scrim views use the entire area, including padding & insets |
| child.layout(0, 0, getMeasuredWidth(), getMeasuredHeight()); |
| } else { |
| // Non-challenge views lay out from the upper left, layered. |
| child.layout(paddingLeft + lp.leftMargin, |
| paddingTop + lp.topMargin + mInsets.top, |
| paddingLeft + child.getMeasuredWidth(), |
| paddingTop + child.getMeasuredHeight() + mInsets.top); |
| } |
| } |
| |
| if (!mHasLayout) { |
| mHasLayout = true; |
| } |
| } |
| |
| @Override |
| public void draw(Canvas c) { |
| super.draw(c); |
| if (DEBUG) { |
| final Paint debugPaint = new Paint(); |
| debugPaint.setColor(0x40FF00CC); |
| // show the isInDragHandle() rect |
| c.drawRect(mDragHandleEdgeSlop, |
| mChallengeView.getTop() - getDragHandleSizeAbove(), |
| getWidth() - mDragHandleEdgeSlop, |
| mChallengeView.getTop() + getDragHandleSizeBelow(), |
| debugPaint); |
| } |
| } |
| |
| @Override |
| protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) { |
| // Focus security fileds before widgets. |
| if (mChallengeView != null && |
| mChallengeView.requestFocus(direction, previouslyFocusedRect)) { |
| return true; |
| } |
| return super.onRequestFocusInDescendants(direction, previouslyFocusedRect); |
| } |
| |
| public void computeScroll() { |
| super.computeScroll(); |
| |
| if (!mScroller.isFinished()) { |
| if (mChallengeView == null) { |
| // Can't scroll if the view is missing. |
| Log.e(TAG, "Challenge view missing in computeScroll"); |
| mScroller.abortAnimation(); |
| return; |
| } |
| |
| mScroller.computeScrollOffset(); |
| moveChallengeTo(mScroller.getCurrY()); |
| |
| if (mScroller.isFinished()) { |
| post(mEndScrollRunnable); |
| } |
| } |
| } |
| |
| private void cancelTransitionsInProgress() { |
| if (!mScroller.isFinished()) { |
| mScroller.abortAnimation(); |
| completeChallengeScroll(); |
| } |
| if (mFader != null) { |
| mFader.cancel(); |
| } |
| } |
| |
| public void fadeInChallenge() { |
| fadeChallenge(true); |
| } |
| |
| public void fadeOutChallenge() { |
| fadeChallenge(false); |
| } |
| |
| public void fadeChallenge(final boolean show) { |
| if (mChallengeView != null) { |
| |
| cancelTransitionsInProgress(); |
| float alpha = show ? 1f : 0f; |
| int duration = show ? CHALLENGE_FADE_IN_DURATION : CHALLENGE_FADE_OUT_DURATION; |
| mFader = ObjectAnimator.ofFloat(mChallengeView, "alpha", alpha); |
| mFader.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| onFadeStart(show); |
| } |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| onFadeEnd(show); |
| } |
| }); |
| mFader.setDuration(duration); |
| mFader.start(); |
| } |
| } |
| |
| private int getMaxChallengeBottom() { |
| if (mChallengeView == null) return 0; |
| final int layoutBottom = getLayoutBottom(); |
| final int challengeHeight = mChallengeView.getMeasuredHeight(); |
| |
| return (layoutBottom + challengeHeight - mChallengeBottomBound); |
| } |
| |
| private int getMinChallengeBottom() { |
| return getLayoutBottom(); |
| } |
| |
| |
| private void onFadeStart(boolean show) { |
| mChallengeInteractiveInternal = false; |
| enableHardwareLayerForChallengeView(); |
| |
| if (show) { |
| moveChallengeTo(getMinChallengeBottom()); |
| } |
| |
| setScrollState(SCROLL_STATE_FADING); |
| } |
| |
| private void enableHardwareLayerForChallengeView() { |
| if (mChallengeView.isHardwareAccelerated()) { |
| mChallengeView.setLayerType(LAYER_TYPE_HARDWARE, null); |
| } |
| } |
| |
| private void onFadeEnd(boolean show) { |
| mChallengeInteractiveInternal = true; |
| setChallengeShowing(show); |
| |
| if (!show) { |
| moveChallengeTo(getMaxChallengeBottom()); |
| } |
| |
| mChallengeView.setLayerType(LAYER_TYPE_NONE, null); |
| mFader = null; |
| setScrollState(SCROLL_STATE_IDLE); |
| } |
| |
| public int getMaxChallengeTop() { |
| if (mChallengeView == null) return 0; |
| |
| final int layoutBottom = getLayoutBottom(); |
| final int challengeHeight = mChallengeView.getMeasuredHeight(); |
| return layoutBottom - challengeHeight - mInsets.top; |
| } |
| |
| /** |
| * Move the bottom edge of mChallengeView to a new position and notify the listener |
| * if it represents a change in position. Changes made through this method will |
| * be stable across layout passes. If this method is called before first layout of |
| * this SlidingChallengeLayout it will have no effect. |
| * |
| * @param bottom New bottom edge in px in this SlidingChallengeLayout's coordinate system. |
| * @return true if the challenge view was moved |
| */ |
| private boolean moveChallengeTo(int bottom) { |
| if (mChallengeView == null || !mHasLayout) { |
| return false; |
| } |
| |
| final int layoutBottom = getLayoutBottom(); |
| final int challengeHeight = mChallengeView.getHeight(); |
| |
| bottom = Math.max(getMinChallengeBottom(), |
| Math.min(bottom, getMaxChallengeBottom())); |
| |
| float offset = 1.f - (float) (bottom - layoutBottom) / |
| (challengeHeight - mChallengeBottomBound); |
| mChallengeOffset = offset; |
| if (offset > 0 && !mChallengeShowing) { |
| setChallengeShowing(true); |
| } |
| |
| mChallengeView.layout(mChallengeView.getLeft(), |
| bottom - mChallengeView.getHeight(), mChallengeView.getRight(), bottom); |
| |
| mChallengeView.setAlpha(getChallengeAlpha()); |
| if (mScrollListener != null) { |
| mScrollListener.onScrollPositionChanged(offset, mChallengeView.getTop()); |
| } |
| postInvalidateOnAnimation(); |
| return true; |
| } |
| |
| /** |
| * The bottom edge of this SlidingChallengeLayout's coordinate system; will coincide with |
| * the bottom edge of mChallengeView when the challenge is fully opened. |
| */ |
| private int getLayoutBottom() { |
| final int bottomMargin = (mChallengeView == null) |
| ? 0 |
| : ((LayoutParams) mChallengeView.getLayoutParams()).bottomMargin; |
| final int layoutBottom = getMeasuredHeight() - getPaddingBottom() - bottomMargin |
| - mInsets.bottom; |
| return layoutBottom; |
| } |
| |
| /** |
| * The bottom edge of mChallengeView; essentially, where the sliding challenge 'is'. |
| */ |
| private int getChallengeBottom() { |
| if (mChallengeView == null) return 0; |
| |
| return mChallengeView.getBottom(); |
| } |
| |
| /** |
| * Show or hide the challenge view, animating it if necessary. |
| * @param show true to show, false to hide |
| */ |
| public void showChallenge(boolean show) { |
| showChallenge(show, 0); |
| if (!show) { |
| // Block any drags in progress so that callers can use this to disable dragging |
| // for other touch interactions. |
| mBlockDrag = true; |
| } |
| } |
| |
| private void showChallenge(int velocity) { |
| boolean show = false; |
| if (Math.abs(velocity) > mMinVelocity) { |
| show = velocity < 0; |
| } else { |
| show = mChallengeOffset >= 0.5f; |
| } |
| showChallenge(show, velocity); |
| } |
| |
| private void showChallenge(boolean show, int velocity) { |
| if (mChallengeView == null) { |
| setChallengeShowing(false); |
| return; |
| } |
| |
| if (mHasLayout) { |
| mChallengeShowingTargetState = show; |
| final int layoutBottom = getLayoutBottom(); |
| animateChallengeTo(show ? layoutBottom : |
| layoutBottom + mChallengeView.getHeight() - mChallengeBottomBound, velocity); |
| } |
| } |
| |
| @Override |
| public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) { |
| return new LayoutParams(getContext(), attrs); |
| } |
| |
| @Override |
| protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) { |
| return p instanceof LayoutParams ? new LayoutParams((LayoutParams) p) : |
| p instanceof MarginLayoutParams ? new LayoutParams((MarginLayoutParams) p) : |
| new LayoutParams(p); |
| } |
| |
| @Override |
| protected ViewGroup.LayoutParams generateDefaultLayoutParams() { |
| return new LayoutParams(); |
| } |
| |
| @Override |
| protected boolean checkLayoutParams(ViewGroup.LayoutParams p) { |
| return p instanceof LayoutParams; |
| } |
| |
| public static class LayoutParams extends MarginLayoutParams { |
| public int childType = CHILD_TYPE_NONE; |
| public static final int CHILD_TYPE_NONE = 0; |
| public static final int CHILD_TYPE_CHALLENGE = 2; |
| public static final int CHILD_TYPE_SCRIM = 4; |
| public static final int CHILD_TYPE_WIDGETS = 5; |
| public static final int CHILD_TYPE_EXPAND_CHALLENGE_HANDLE = 6; |
| |
| public int maxHeight; |
| |
| public LayoutParams() { |
| this(MATCH_PARENT, WRAP_CONTENT); |
| } |
| |
| public LayoutParams(int width, int height) { |
| super(width, height); |
| } |
| |
| public LayoutParams(android.view.ViewGroup.LayoutParams source) { |
| super(source); |
| } |
| |
| public LayoutParams(MarginLayoutParams source) { |
| super(source); |
| } |
| |
| public LayoutParams(LayoutParams source) { |
| super(source); |
| |
| childType = source.childType; |
| } |
| |
| public LayoutParams(Context c, AttributeSet attrs) { |
| super(c, attrs); |
| |
| final TypedArray a = c.obtainStyledAttributes(attrs, |
| R.styleable.SlidingChallengeLayout_Layout); |
| childType = a.getInt(R.styleable.SlidingChallengeLayout_Layout_layout_childType, |
| CHILD_TYPE_NONE); |
| maxHeight = a.getDimensionPixelSize( |
| R.styleable.SlidingChallengeLayout_Layout_layout_maxHeight, 0); |
| a.recycle(); |
| } |
| } |
| } |
