1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.systemui.statusbar; 18 19 import android.animation.Animator; 20 import android.animation.AnimatorListenerAdapter; 21 import android.animation.ObjectAnimator; 22 import android.animation.ValueAnimator; 23 import android.content.Context; 24 import android.view.MotionEvent; 25 import android.view.View; 26 import android.view.ViewConfiguration; 27 import android.view.animation.AnimationUtils; 28 import android.view.animation.Interpolator; 29 import com.android.systemui.ExpandHelper; 30 import com.android.systemui.Gefingerpoken; 31 import com.android.systemui.R; 32 33 /** 34 * A utility class to enable the downward swipe on the lockscreen to go to the full shade and expand 35 * the notification where the drag started. 36 */ 37 public class DragDownHelper implements Gefingerpoken { 38 39 private static final float RUBBERBAND_FACTOR_EXPANDABLE = 0.5f; 40 private static final float RUBBERBAND_FACTOR_STATIC = 0.15f; 41 42 private static final int SPRING_BACK_ANIMATION_LENGTH_MS = 375; 43 44 private int mMinDragDistance; 45 private ExpandHelper.Callback mCallback; 46 private float mInitialTouchX; 47 private float mInitialTouchY; 48 private boolean mDraggingDown; 49 private float mTouchSlop; 50 private DragDownCallback mDragDownCallback; 51 private View mHost; 52 private final int[] mTemp2 = new int[2]; 53 private boolean mDraggedFarEnough; 54 private ExpandableView mStartingChild; 55 private Interpolator mInterpolator; 56 private float mLastHeight; 57 58 public DragDownHelper(Context context, View host, ExpandHelper.Callback callback, 59 DragDownCallback dragDownCallback) { 60 mMinDragDistance = context.getResources().getDimensionPixelSize( 61 R.dimen.keyguard_drag_down_min_distance); 62 mInterpolator = 63 AnimationUtils.loadInterpolator(context, android.R.interpolator.fast_out_slow_in); 64 mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop(); 65 mCallback = callback; 66 mDragDownCallback = dragDownCallback; 67 mHost = host; 68 } 69 70 @Override 71 public boolean onInterceptTouchEvent(MotionEvent event) { 72 final float x = event.getX(); 73 final float y = event.getY(); 74 75 switch (event.getActionMasked()) { 76 case MotionEvent.ACTION_DOWN: 77 mDraggedFarEnough = false; 78 mDraggingDown = false; 79 mStartingChild = null; 80 mInitialTouchY = y; 81 mInitialTouchX = x; 82 break; 83 84 case MotionEvent.ACTION_MOVE: 85 final float h = y - mInitialTouchY; 86 if (h > mTouchSlop && h > Math.abs(x - mInitialTouchX)) { 87 mDraggingDown = true; 88 captureStartingChild(mInitialTouchX, mInitialTouchY); 89 mInitialTouchY = y; 90 mInitialTouchX = x; 91 mDragDownCallback.onTouchSlopExceeded(); 92 return true; 93 } 94 break; 95 } 96 return false; 97 } 98 99 @Override 100 public boolean onTouchEvent(MotionEvent event) { 101 if (!mDraggingDown) { 102 return false; 103 } 104 final float x = event.getX(); 105 final float y = event.getY(); 106 107 switch (event.getActionMasked()) { 108 case MotionEvent.ACTION_MOVE: 109 mLastHeight = y - mInitialTouchY; 110 captureStartingChild(mInitialTouchX, mInitialTouchY); 111 if (mStartingChild != null) { 112 handleExpansion(mLastHeight, mStartingChild); 113 } else { 114 mDragDownCallback.setEmptyDragAmount(mLastHeight); 115 } 116 if (mLastHeight > mMinDragDistance) { 117 if (!mDraggedFarEnough) { 118 mDraggedFarEnough = true; 119 mDragDownCallback.onThresholdReached(); 120 } 121 } else { 122 if (mDraggedFarEnough) { 123 mDraggedFarEnough = false; 124 mDragDownCallback.onDragDownReset(); 125 } 126 } 127 return true; 128 case MotionEvent.ACTION_UP: 129 if (mDraggedFarEnough && mDragDownCallback.onDraggedDown(mStartingChild)) { 130 if (mStartingChild == null) { 131 mDragDownCallback.setEmptyDragAmount(0f); 132 } 133 mDraggingDown = false; 134 } else { 135 stopDragging(); 136 return false; 137 } 138 break; 139 case MotionEvent.ACTION_CANCEL: 140 stopDragging(); 141 return false; 142 } 143 return false; 144 } 145 146 private void captureStartingChild(float x, float y) { 147 if (mStartingChild == null) { 148 mStartingChild = findView(x, y); 149 if (mStartingChild != null) { 150 mCallback.setUserLockedChild(mStartingChild, true); 151 } 152 } 153 } 154 155 private void handleExpansion(float heightDelta, ExpandableView child) { 156 if (heightDelta < 0) { 157 heightDelta = 0; 158 } 159 boolean expandable = child.isContentExpandable(); 160 float rubberbandFactor = expandable 161 ? RUBBERBAND_FACTOR_EXPANDABLE 162 : RUBBERBAND_FACTOR_STATIC; 163 float rubberband = heightDelta * rubberbandFactor; 164 if (expandable && (rubberband + child.getMinHeight()) > child.getMaxHeight()) { 165 float overshoot = (rubberband + child.getMinHeight()) - child.getMaxHeight(); 166 overshoot *= (1 - RUBBERBAND_FACTOR_STATIC); 167 rubberband -= overshoot; 168 } 169 child.setActualHeight((int) (child.getMinHeight() + rubberband)); 170 } 171 172 private void cancelExpansion(final ExpandableView child) { 173 if (child.getActualHeight() == child.getMinHeight()) { 174 return; 175 } 176 ObjectAnimator anim = ObjectAnimator.ofInt(child, "actualHeight", 177 child.getActualHeight(), child.getMinHeight()); 178 anim.setInterpolator(mInterpolator); 179 anim.setDuration(SPRING_BACK_ANIMATION_LENGTH_MS); 180 anim.addListener(new AnimatorListenerAdapter() { 181 @Override 182 public void onAnimationEnd(Animator animation) { 183 mCallback.setUserLockedChild(child, false); 184 } 185 }); 186 anim.start(); 187 } 188 189 private void cancelExpansion() { 190 ValueAnimator anim = ValueAnimator.ofFloat(mLastHeight, 0); 191 anim.setInterpolator(mInterpolator); 192 anim.setDuration(SPRING_BACK_ANIMATION_LENGTH_MS); 193 anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { 194 @Override 195 public void onAnimationUpdate(ValueAnimator animation) { 196 mDragDownCallback.setEmptyDragAmount((Float) animation.getAnimatedValue()); 197 } 198 }); 199 anim.start(); 200 } 201 202 private void stopDragging() { 203 if (mStartingChild != null) { 204 cancelExpansion(mStartingChild); 205 } else { 206 cancelExpansion(); 207 } 208 mDraggingDown = false; 209 mDragDownCallback.onDragDownReset(); 210 } 211 212 private ExpandableView findView(float x, float y) { 213 mHost.getLocationOnScreen(mTemp2); 214 x += mTemp2[0]; 215 y += mTemp2[1]; 216 return mCallback.getChildAtRawPosition(x, y); 217 } 218 219 public interface DragDownCallback { 220 221 /** 222 * @return true if the interaction is accepted, false if it should be cancelled 223 */ 224 boolean onDraggedDown(View startingChild); 225 void onDragDownReset(); 226 void onThresholdReached(); 227 void onTouchSlopExceeded(); 228 void setEmptyDragAmount(float amount); 229 } 230 } 231