blob: 107f8ef9d603ed4282d2135c9611db2417c7fcc0 [file] [log] [blame]
The Android Open Source Project31dd5032009-03-03 19:32:27 -08001/*
2 * Copyright (C) 2008 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
Joe Onoratoa5902522009-07-30 13:37:37 -070017package com.android.launcher2;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080018
Joe Onorato00acb122009-08-04 16:04:30 -040019import android.content.Context;
20import android.graphics.Bitmap;
Joe Onorato00acb122009-08-04 16:04:30 -040021import android.graphics.Rect;
22import android.graphics.RectF;
Joe Onorato00acb122009-08-04 16:04:30 -040023import android.os.Handler;
Michael Jurka0280c3b2010-09-17 15:00:07 -070024import android.os.IBinder;
Joe Onorato00acb122009-08-04 16:04:30 -040025import android.os.Vibrator;
Joe Onorato00acb122009-08-04 16:04:30 -040026import android.util.Log;
Joe Onorato00acb122009-08-04 16:04:30 -040027import android.view.KeyEvent;
28import android.view.MotionEvent;
Michael Jurka0280c3b2010-09-17 15:00:07 -070029import android.view.View;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -070030import android.view.ViewConfiguration;
Joe Onorato00acb122009-08-04 16:04:30 -040031import android.view.inputmethod.InputMethodManager;
Joe Onorato00acb122009-08-04 16:04:30 -040032
Adam Cohen120980b2010-12-08 11:05:37 -080033import com.android.launcher.R;
Adam Cohenc0dcf592011-06-01 15:30:43 -070034
35import java.util.ArrayList;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080036
37/**
Joe Onorato00acb122009-08-04 16:04:30 -040038 * Class for initiating a drag within a view or across multiple views.
The Android Open Source Project31dd5032009-03-03 19:32:27 -080039 */
Joe Onorato00acb122009-08-04 16:04:30 -040040public class DragController {
Romain Guyea3763c2010-01-11 18:02:04 -080041 @SuppressWarnings({"UnusedDeclaration"})
Joe Onorato2e5c4322009-10-06 12:34:42 -070042 private static final String TAG = "Launcher.DragController";
43
Joe Onorato00acb122009-08-04 16:04:30 -040044 /** Indicates the drag is a move. */
45 public static int DRAG_ACTION_MOVE = 0;
46
47 /** Indicates the drag is a copy. */
48 public static int DRAG_ACTION_COPY = 1;
49
50 private static final int SCROLL_DELAY = 600;
Joe Onorato00acb122009-08-04 16:04:30 -040051 private static final int VIBRATE_DURATION = 35;
52
53 private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
54
55 private static final int SCROLL_OUTSIDE_ZONE = 0;
56 private static final int SCROLL_WAITING_IN_ZONE = 1;
57
Patrick Dubroy54fa3b92010-11-17 12:18:45 -080058 static final int SCROLL_NONE = -1;
Patrick Dubroy1262e362010-10-06 15:49:50 -070059 static final int SCROLL_LEFT = 0;
60 static final int SCROLL_RIGHT = 1;
Joe Onorato00acb122009-08-04 16:04:30 -040061
Adam Cohen8dfcba42011-07-07 16:38:18 -070062 private Launcher mLauncher;
Joe Onorato00acb122009-08-04 16:04:30 -040063 private Handler mHandler;
64 private final Vibrator mVibrator = new Vibrator();
65
66 // temporaries to avoid gc thrash
67 private Rect mRectTemp = new Rect();
68 private final int[] mCoordinatesTemp = new int[2];
69
70 /** Whether or not we're dragging. */
71 private boolean mDragging;
72
73 /** X coordinate of the down event. */
Adam Cohene3e27a82011-04-15 12:07:39 -070074 private int mMotionDownX;
Joe Onorato00acb122009-08-04 16:04:30 -040075
76 /** Y coordinate of the down event. */
Adam Cohene3e27a82011-04-15 12:07:39 -070077 private int mMotionDownY;
Joe Onorato00acb122009-08-04 16:04:30 -040078
Joe Onorato658db742010-09-29 11:40:39 -070079 /** the area at the edge of the screen that makes the workspace go left
80 * or right while you're dragging.
81 */
82 private int mScrollZone;
83
Adam Cohen9932a9b2011-08-02 22:14:07 -070084 private DropTarget.DragObject mDragObject;
Joe Onorato00acb122009-08-04 16:04:30 -040085
86 /** Who can receive drop events */
87 private ArrayList<DropTarget> mDropTargets = new ArrayList<DropTarget>();
88
Patrick Dubroy4ed62782010-08-17 15:11:18 -070089 private ArrayList<DragListener> mListeners = new ArrayList<DragListener>();
Joe Onorato00acb122009-08-04 16:04:30 -040090
91 /** The window token used as the parent for the DragView. */
92 private IBinder mWindowToken;
93
94 /** The view that will be scrolled when dragging to the left and right edges of the screen. */
95 private View mScrollView;
96
Romain Guyea3763c2010-01-11 18:02:04 -080097 private View mMoveTarget;
98
Joe Onorato00acb122009-08-04 16:04:30 -040099 private DragScroller mDragScroller;
100 private int mScrollState = SCROLL_OUTSIDE_ZONE;
101 private ScrollRunnable mScrollRunnable = new ScrollRunnable();
102
103 private RectF mDeleteRegion;
104 private DropTarget mLastDropTarget;
105
106 private InputMethodManager mInputMethodManager;
107
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700108 private int mLastTouch[] = new int[2];
109 private int mDistanceSinceScroll = 0;
110
Winson Chung273c1022011-07-11 13:40:52 -0700111 private int mTmpPoint[] = new int[2];
112 private Rect mDragLayerRect = new Rect();
113
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800114 /**
115 * Interface to receive notifications when a drag starts or stops
116 */
117 interface DragListener {
118
119 /**
120 * A drag has begun
121 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800122 * @param source An object representing where the drag originated
123 * @param info The data associated with the object that is being dragged
124 * @param dragAction The drag action: either {@link DragController#DRAG_ACTION_MOVE}
125 * or {@link DragController#DRAG_ACTION_COPY}
126 */
Joe Onorato5162ea92009-09-03 09:39:42 -0700127 void onDragStart(DragSource source, Object info, int dragAction);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800128
129 /**
Winson Chunge3193b92010-09-10 11:44:42 -0700130 * The drag has ended
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800131 */
132 void onDragEnd();
133 }
134
135 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400136 * Used to create a new DragLayer from XML.
137 *
138 * @param context The application's context.
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800139 */
Adam Cohen8dfcba42011-07-07 16:38:18 -0700140 public DragController(Launcher launcher) {
141 mLauncher = launcher;
Joe Onorato00acb122009-08-04 16:04:30 -0400142 mHandler = new Handler();
Adam Cohen8dfcba42011-07-07 16:38:18 -0700143 mScrollZone = launcher.getResources().getDimensionPixelSize(R.dimen.scroll_zone);
Joe Onorato00acb122009-08-04 16:04:30 -0400144 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800145
Patrick Dubroy1262e362010-10-06 15:49:50 -0700146 public boolean dragging() {
147 return mDragging;
148 }
149
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800150 /**
Joe Onorato5162ea92009-09-03 09:39:42 -0700151 * Starts a drag.
Michael Jurkaa63c4522010-08-19 13:52:27 -0700152 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800153 * @param v The view that is being dragged
154 * @param source An object representing where the drag originated
Romain Guyea3763c2010-01-11 18:02:04 -0800155 * @param dragInfo The data associated with the object that is being dragged
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800156 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
157 * {@link #DRAG_ACTION_COPY}
158 */
Joe Onorato00acb122009-08-04 16:04:30 -0400159 public void startDrag(View v, DragSource source, Object dragInfo, int dragAction) {
Michael Jurkaa63c4522010-08-19 13:52:27 -0700160 startDrag(v, source, dragInfo, dragAction, null);
161 }
162
163 /**
164 * Starts a drag.
165 *
166 * @param v The view that is being dragged
167 * @param source An object representing where the drag originated
168 * @param dragInfo The data associated with the object that is being dragged
169 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
170 * {@link #DRAG_ACTION_COPY}
171 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
172 * Makes dragging feel more precise, e.g. you can clip out a transparent border
173 */
174 public void startDrag(View v, DragSource source, Object dragInfo, int dragAction,
175 Rect dragRegion) {
Joe Onorato5162ea92009-09-03 09:39:42 -0700176 Bitmap b = getViewBitmap(v);
177
Daniel Sandler3f8175a2010-05-25 11:48:32 -0400178 if (b == null) {
179 // out of memory?
180 return;
181 }
182
Joe Onorato5162ea92009-09-03 09:39:42 -0700183 int[] loc = mCoordinatesTemp;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700184 mLauncher.getDragLayer().getLocationInDragLayer(v, loc);
185 int dragLayerX = loc[0];
186 int dragLayerY = loc[1];
Joe Onorato5162ea92009-09-03 09:39:42 -0700187
Adam Cohen8dfcba42011-07-07 16:38:18 -0700188 startDrag(b, dragLayerX, dragLayerY, source, dragInfo, dragAction, dragRegion);
Joe Onorato5162ea92009-09-03 09:39:42 -0700189 b.recycle();
190
191 if (dragAction == DRAG_ACTION_MOVE) {
192 v.setVisibility(View.GONE);
193 }
194 }
195
196 /**
197 * Starts a drag.
Michael Jurkaa63c4522010-08-19 13:52:27 -0700198 *
Winson Chunge3193b92010-09-10 11:44:42 -0700199 * @param v The view that is being dragged
200 * @param bmp The bitmap that represents the view being dragged
201 * @param source An object representing where the drag originated
202 * @param dragInfo The data associated with the object that is being dragged
203 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
204 * {@link #DRAG_ACTION_COPY}
205 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
206 * Makes dragging feel more precise, e.g. you can clip out a transparent border
207 */
208 public void startDrag(View v, Bitmap bmp, DragSource source, Object dragInfo, int dragAction,
209 Rect dragRegion) {
Winson Chunge3193b92010-09-10 11:44:42 -0700210 int[] loc = mCoordinatesTemp;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700211 mLauncher.getDragLayer().getLocationInDragLayer(v, loc);
212 int dragLayerX = loc[0];
213 int dragLayerY = loc[1];
Winson Chunge3193b92010-09-10 11:44:42 -0700214
Adam Cohen8dfcba42011-07-07 16:38:18 -0700215 startDrag(bmp, dragLayerX, dragLayerY, source, dragInfo, dragAction, dragRegion);
Winson Chunge3193b92010-09-10 11:44:42 -0700216
217 if (dragAction == DRAG_ACTION_MOVE) {
218 v.setVisibility(View.GONE);
219 }
220 }
221
222 /**
223 * Starts a drag.
224 *
Joe Onorato5162ea92009-09-03 09:39:42 -0700225 * @param b The bitmap to display as the drag image. It will be re-scaled to the
226 * enlarged size.
Adam Cohen8dfcba42011-07-07 16:38:18 -0700227 * @param dragLayerX The x position in the DragLayer of the left-top of the bitmap.
228 * @param dragLayerY The y position in the DragLayer of the left-top of the bitmap.
Joe Onorato5162ea92009-09-03 09:39:42 -0700229 * @param source An object representing where the drag originated
Romain Guyea3763c2010-01-11 18:02:04 -0800230 * @param dragInfo The data associated with the object that is being dragged
Joe Onorato5162ea92009-09-03 09:39:42 -0700231 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
232 * {@link #DRAG_ACTION_COPY}
233 */
Adam Cohen8dfcba42011-07-07 16:38:18 -0700234 public void startDrag(Bitmap b, int dragLayerX, int dragLayerY,
Joe Onorato5162ea92009-09-03 09:39:42 -0700235 DragSource source, Object dragInfo, int dragAction) {
Adam Cohen8dfcba42011-07-07 16:38:18 -0700236 startDrag(b, dragLayerX, dragLayerY, source, dragInfo, dragAction, null);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700237 }
238
239 /**
240 * Starts a drag.
241 *
242 * @param b The bitmap to display as the drag image. It will be re-scaled to the
243 * enlarged size.
Adam Cohen8dfcba42011-07-07 16:38:18 -0700244 * @param dragLayerX The x position in the DragLayer of the left-top of the bitmap.
245 * @param dragLayerY The y position in the DragLayer of the left-top of the bitmap.
Michael Jurkaa63c4522010-08-19 13:52:27 -0700246 * @param source An object representing where the drag originated
247 * @param dragInfo The data associated with the object that is being dragged
248 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
249 * {@link #DRAG_ACTION_COPY}
250 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
251 * Makes dragging feel more precise, e.g. you can clip out a transparent border
252 */
Adam Cohen8dfcba42011-07-07 16:38:18 -0700253 public void startDrag(Bitmap b, int dragLayerX, int dragLayerY,
Michael Jurkaa63c4522010-08-19 13:52:27 -0700254 DragSource source, Object dragInfo, int dragAction, Rect dragRegion) {
Joe Onorato00acb122009-08-04 16:04:30 -0400255 if (PROFILE_DRAWING_DURING_DRAG) {
256 android.os.Debug.startMethodTracing("Launcher");
257 }
258
259 // Hide soft keyboard, if visible
260 if (mInputMethodManager == null) {
261 mInputMethodManager = (InputMethodManager)
Adam Cohen8dfcba42011-07-07 16:38:18 -0700262 mLauncher.getSystemService(Context.INPUT_METHOD_SERVICE);
Joe Onorato00acb122009-08-04 16:04:30 -0400263 }
264 mInputMethodManager.hideSoftInputFromWindow(mWindowToken, 0);
265
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700266 for (DragListener listener : mListeners) {
267 listener.onDragStart(source, dragInfo, dragAction);
Joe Onorato00acb122009-08-04 16:04:30 -0400268 }
269
Adam Cohen8dfcba42011-07-07 16:38:18 -0700270 final int registrationX = mMotionDownX - dragLayerX;
271 final int registrationY = mMotionDownY - dragLayerY;
Joe Onorato00acb122009-08-04 16:04:30 -0400272
Michael Jurkaa63c4522010-08-19 13:52:27 -0700273 final int dragRegionLeft = dragRegion == null ? 0 : dragRegion.left;
274 final int dragRegionTop = dragRegion == null ? 0 : dragRegion.top;
Adam Cohene3e27a82011-04-15 12:07:39 -0700275
Joe Onorato00acb122009-08-04 16:04:30 -0400276 mDragging = true;
Adam Cohencb3382b2011-05-24 14:07:08 -0700277
Adam Cohen9932a9b2011-08-02 22:14:07 -0700278 mDragObject = new DropTarget.DragObject();
279
Adam Cohenbfbfd262011-06-13 16:55:12 -0700280 mDragObject.dragComplete = false;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700281 mDragObject.xOffset = mMotionDownX - (dragLayerX + dragRegionLeft);
282 mDragObject.yOffset = mMotionDownY - (dragLayerY + dragRegionTop);
Adam Cohencb3382b2011-05-24 14:07:08 -0700283 mDragObject.dragSource = source;
284 mDragObject.dragInfo = dragInfo;
Joe Onorato00acb122009-08-04 16:04:30 -0400285
286 mVibrator.vibrate(VIBRATE_DURATION);
287
Adam Cohen8dfcba42011-07-07 16:38:18 -0700288 final DragView dragView = mDragObject.dragView = new DragView(mLauncher, b, registrationX,
Adam Cohencb3382b2011-05-24 14:07:08 -0700289 registrationY, 0, 0, b.getWidth(), b.getHeight());
Michael Jurkaa63c4522010-08-19 13:52:27 -0700290
291 if (dragRegion != null) {
Adam Cohene3e27a82011-04-15 12:07:39 -0700292 dragView.setDragRegion(new Rect(dragRegion));
Michael Jurkaa63c4522010-08-19 13:52:27 -0700293 }
294
Adam Cohen8dfcba42011-07-07 16:38:18 -0700295 dragView.show(mMotionDownX, mMotionDownY);
296 handleMoveEvent(mMotionDownX, mMotionDownY);
Joe Onorato00acb122009-08-04 16:04:30 -0400297 }
298
299 /**
300 * Draw the view into a bitmap.
301 */
Adam Cohen120980b2010-12-08 11:05:37 -0800302 Bitmap getViewBitmap(View v) {
Joe Onorato00acb122009-08-04 16:04:30 -0400303 v.clearFocus();
304 v.setPressed(false);
305
306 boolean willNotCache = v.willNotCacheDrawing();
307 v.setWillNotCacheDrawing(false);
308
309 // Reset the drawing cache background color to fully transparent
310 // for the duration of this operation
311 int color = v.getDrawingCacheBackgroundColor();
312 v.setDrawingCacheBackgroundColor(0);
Adam Cohen120980b2010-12-08 11:05:37 -0800313 float alpha = v.getAlpha();
314 v.setAlpha(1.0f);
Joe Onorato00acb122009-08-04 16:04:30 -0400315
316 if (color != 0) {
317 v.destroyDrawingCache();
318 }
319 v.buildDrawingCache();
320 Bitmap cacheBitmap = v.getDrawingCache();
Daniel Sandler3f8175a2010-05-25 11:48:32 -0400321 if (cacheBitmap == null) {
322 Log.e(TAG, "failed getViewBitmap(" + v + ")", new RuntimeException());
323 return null;
324 }
Joe Onorato00acb122009-08-04 16:04:30 -0400325
326 Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);
327
328 // Restore the view
329 v.destroyDrawingCache();
Adam Cohen120980b2010-12-08 11:05:37 -0800330 v.setAlpha(alpha);
Joe Onorato00acb122009-08-04 16:04:30 -0400331 v.setWillNotCacheDrawing(willNotCache);
332 v.setDrawingCacheBackgroundColor(color);
333
334 return bitmap;
335 }
336
337 /**
338 * Call this from a drag source view like this:
339 *
340 * <pre>
341 * @Override
342 * public boolean dispatchKeyEvent(KeyEvent event) {
343 * return mDragController.dispatchKeyEvent(this, event)
344 * || super.dispatchKeyEvent(event);
345 * </pre>
346 */
Romain Guyea3763c2010-01-11 18:02:04 -0800347 @SuppressWarnings({"UnusedDeclaration"})
Joe Onorato00acb122009-08-04 16:04:30 -0400348 public boolean dispatchKeyEvent(KeyEvent event) {
349 return mDragging;
350 }
351
Winson Chung304dcde2011-01-07 11:17:23 -0800352 public boolean isDragging() {
353 return mDragging;
354 }
355
Joe Onorato24b6fd82009-11-12 13:47:09 -0800356 /**
357 * Stop dragging without dropping.
358 */
359 public void cancelDrag() {
Winson Chung621e6402011-01-04 16:03:57 -0800360 if (mDragging) {
Winson Chungc07918d2011-07-01 15:35:26 -0700361 if (mLastDropTarget != null) {
362 mLastDropTarget.onDragExit(mDragObject);
363 }
Adam Cohen36cc09b2011-09-29 17:33:15 -0700364 mDragObject.cancelled = true;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700365 mDragObject.dragComplete = true;
Adam Cohenc0dcf592011-06-01 15:30:43 -0700366 mDragObject.dragSource.onDropCompleted(null, mDragObject, false);
Winson Chung621e6402011-01-04 16:03:57 -0800367 }
Joe Onorato24b6fd82009-11-12 13:47:09 -0800368 endDrag();
369 }
370
Joe Onorato00acb122009-08-04 16:04:30 -0400371 private void endDrag() {
372 if (mDragging) {
373 mDragging = false;
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700374 for (DragListener listener : mListeners) {
375 listener.onDragEnd();
Joe Onorato00acb122009-08-04 16:04:30 -0400376 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700377 if (mDragObject.dragView != null) {
378 mDragObject.dragView.remove();
379 mDragObject.dragView = null;
Joe Onorato00acb122009-08-04 16:04:30 -0400380 }
Joe Onorato00acb122009-08-04 16:04:30 -0400381 }
382 }
383
384 /**
Winson Chung273c1022011-07-11 13:40:52 -0700385 * Clamps the position to the drag layer bounds.
386 */
387 private int[] getClampedDragLayerPos(float x, float y) {
388 mLauncher.getDragLayer().getLocalVisibleRect(mDragLayerRect);
389 mTmpPoint[0] = (int) Math.max(mDragLayerRect.left, Math.min(x, mDragLayerRect.right - 1));
390 mTmpPoint[1] = (int) Math.max(mDragLayerRect.top, Math.min(y, mDragLayerRect.bottom - 1));
391 return mTmpPoint;
392 }
393
394 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400395 * Call this from a drag source view.
396 */
397 public boolean onInterceptTouchEvent(MotionEvent ev) {
Joe Onorato9c1289c2009-08-17 11:03:03 -0400398 if (false) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -0800399 Log.d(Launcher.TAG, "DragController.onInterceptTouchEvent " + ev + " mDragging="
Joe Onorato9c1289c2009-08-17 11:03:03 -0400400 + mDragging);
401 }
Joe Onorato00acb122009-08-04 16:04:30 -0400402 final int action = ev.getAction();
403
Winson Chung273c1022011-07-11 13:40:52 -0700404 final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
405 final int dragLayerX = dragLayerPos[0];
406 final int dragLayerY = dragLayerPos[1];
Joe Onorato00acb122009-08-04 16:04:30 -0400407
408 switch (action) {
409 case MotionEvent.ACTION_MOVE:
410 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400411 case MotionEvent.ACTION_DOWN:
412 // Remember location of down touch
Adam Cohen8dfcba42011-07-07 16:38:18 -0700413 mMotionDownX = dragLayerX;
414 mMotionDownY = dragLayerY;
Joe Onorato00acb122009-08-04 16:04:30 -0400415 mLastDropTarget = null;
416 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400417 case MotionEvent.ACTION_UP:
418 if (mDragging) {
Adam Cohen8dfcba42011-07-07 16:38:18 -0700419 drop(dragLayerX, dragLayerY);
Joe Onorato00acb122009-08-04 16:04:30 -0400420 }
421 endDrag();
422 break;
Winson Chung621e6402011-01-04 16:03:57 -0800423 case MotionEvent.ACTION_CANCEL:
424 cancelDrag();
425 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400426 }
427
428 return mDragging;
429 }
430
431 /**
Romain Guyea3763c2010-01-11 18:02:04 -0800432 * Sets the view that should handle move events.
433 */
434 void setMoveTarget(View view) {
435 mMoveTarget = view;
436 }
437
438 public boolean dispatchUnhandledMove(View focused, int direction) {
439 return mMoveTarget != null && mMoveTarget.dispatchUnhandledMove(focused, direction);
440 }
441
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700442 private void handleMoveEvent(int x, int y) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700443 mDragObject.dragView.move(x, y);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700444
445 // Drop on someone?
446 final int[] coordinates = mCoordinatesTemp;
447 DropTarget dropTarget = findDropTarget(x, y, coordinates);
Adam Cohencb3382b2011-05-24 14:07:08 -0700448 mDragObject.x = coordinates[0];
449 mDragObject.y = coordinates[1];
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700450 if (dropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700451 DropTarget delegate = dropTarget.getDropTargetDelegate(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700452 if (delegate != null) {
453 dropTarget = delegate;
454 }
455
456 if (mLastDropTarget != dropTarget) {
457 if (mLastDropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700458 mLastDropTarget.onDragExit(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700459 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700460 dropTarget.onDragEnter(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700461 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700462 dropTarget.onDragOver(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700463 } else {
464 if (mLastDropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700465 mLastDropTarget.onDragExit(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700466 }
467 }
468 mLastDropTarget = dropTarget;
469
470 // Scroll, maybe, but not if we're in the delete region.
471 boolean inDeleteRegion = false;
472 if (mDeleteRegion != null) {
473 inDeleteRegion = mDeleteRegion.contains(x, y);
474 }
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700475
476 // After a scroll, the touch point will still be in the scroll region.
477 // Rather than scrolling immediately, require a bit of twiddling to scroll again
Adam Cohen8dfcba42011-07-07 16:38:18 -0700478 final int slop = ViewConfiguration.get(mLauncher).getScaledWindowTouchSlop();
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700479 mDistanceSinceScroll +=
480 Math.sqrt(Math.pow(mLastTouch[0] - x, 2) + Math.pow(mLastTouch[1] - y, 2));
481 mLastTouch[0] = x;
482 mLastTouch[1] = y;
483
Joe Onorato658db742010-09-29 11:40:39 -0700484 if (!inDeleteRegion && x < mScrollZone) {
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700485 if (mScrollState == SCROLL_OUTSIDE_ZONE && mDistanceSinceScroll > slop) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700486 mScrollState = SCROLL_WAITING_IN_ZONE;
Winson Chung3e0839e2011-10-03 15:15:18 -0700487 if (mDragScroller.onEnterScrollArea(x, y, SCROLL_LEFT)) {
488 mScrollRunnable.setDirection(SCROLL_LEFT);
489 mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
490 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700491 }
Joe Onorato658db742010-09-29 11:40:39 -0700492 } else if (!inDeleteRegion && x > mScrollView.getWidth() - mScrollZone) {
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700493 if (mScrollState == SCROLL_OUTSIDE_ZONE && mDistanceSinceScroll > slop) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700494 mScrollState = SCROLL_WAITING_IN_ZONE;
Winson Chung3e0839e2011-10-03 15:15:18 -0700495 if (mDragScroller.onEnterScrollArea(x, y, SCROLL_RIGHT)) {
496 mScrollRunnable.setDirection(SCROLL_RIGHT);
497 mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
498 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700499 }
500 } else {
501 if (mScrollState == SCROLL_WAITING_IN_ZONE) {
502 mScrollState = SCROLL_OUTSIDE_ZONE;
503 mScrollRunnable.setDirection(SCROLL_RIGHT);
504 mHandler.removeCallbacks(mScrollRunnable);
Patrick Dubroy1262e362010-10-06 15:49:50 -0700505 mDragScroller.onExitScrollArea();
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700506 }
507 }
508 }
509
Romain Guyea3763c2010-01-11 18:02:04 -0800510 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400511 * Call this from a drag source view.
512 */
513 public boolean onTouchEvent(MotionEvent ev) {
Joe Onorato00acb122009-08-04 16:04:30 -0400514 if (!mDragging) {
515 return false;
516 }
517
518 final int action = ev.getAction();
Winson Chung273c1022011-07-11 13:40:52 -0700519 final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
520 final int dragLayerX = dragLayerPos[0];
521 final int dragLayerY = dragLayerPos[1];
Joe Onorato00acb122009-08-04 16:04:30 -0400522
523 switch (action) {
524 case MotionEvent.ACTION_DOWN:
Joe Onorato00acb122009-08-04 16:04:30 -0400525 // Remember where the motion event started
Adam Cohen8dfcba42011-07-07 16:38:18 -0700526 mMotionDownX = dragLayerX;
527 mMotionDownY = dragLayerY;
Joe Onorato00acb122009-08-04 16:04:30 -0400528
Adam Cohen8dfcba42011-07-07 16:38:18 -0700529 if ((dragLayerX < mScrollZone) || (dragLayerX > mScrollView.getWidth() - mScrollZone)) {
Joe Onorato00acb122009-08-04 16:04:30 -0400530 mScrollState = SCROLL_WAITING_IN_ZONE;
531 mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
532 } else {
533 mScrollState = SCROLL_OUTSIDE_ZONE;
534 }
Joe Onorato00acb122009-08-04 16:04:30 -0400535 break;
536 case MotionEvent.ACTION_MOVE:
Adam Cohen8dfcba42011-07-07 16:38:18 -0700537 handleMoveEvent(dragLayerX, dragLayerY);
Joe Onorato00acb122009-08-04 16:04:30 -0400538 break;
539 case MotionEvent.ACTION_UP:
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800540 // Ensure that we've processed a move event at the current pointer location.
Adam Cohen8dfcba42011-07-07 16:38:18 -0700541 handleMoveEvent(dragLayerX, dragLayerY);
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800542
Joe Onorato00acb122009-08-04 16:04:30 -0400543 mHandler.removeCallbacks(mScrollRunnable);
544 if (mDragging) {
Adam Cohen8dfcba42011-07-07 16:38:18 -0700545 drop(dragLayerX, dragLayerY);
Joe Onorato00acb122009-08-04 16:04:30 -0400546 }
547 endDrag();
Joe Onorato00acb122009-08-04 16:04:30 -0400548 break;
549 case MotionEvent.ACTION_CANCEL:
Joe Onorato24b6fd82009-11-12 13:47:09 -0800550 cancelDrag();
Winson Chung621e6402011-01-04 16:03:57 -0800551 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400552 }
553
554 return true;
555 }
556
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800557 private void drop(float x, float y) {
Joe Onorato00acb122009-08-04 16:04:30 -0400558 final int[] coordinates = mCoordinatesTemp;
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800559 final DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);
Joe Onorato00acb122009-08-04 16:04:30 -0400560
Adam Cohencb3382b2011-05-24 14:07:08 -0700561 mDragObject.x = coordinates[0];
562 mDragObject.y = coordinates[1];
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800563 boolean accepted = false;
Joe Onorato00acb122009-08-04 16:04:30 -0400564 if (dropTarget != null) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700565 mDragObject.dragComplete = true;
Adam Cohencb3382b2011-05-24 14:07:08 -0700566 dropTarget.onDragExit(mDragObject);
567 if (dropTarget.acceptDrop(mDragObject)) {
568 dropTarget.onDrop(mDragObject);
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800569 accepted = true;
Joe Onorato00acb122009-08-04 16:04:30 -0400570 }
571 }
Adam Cohenc0dcf592011-06-01 15:30:43 -0700572 mDragObject.dragSource.onDropCompleted((View) dropTarget, mDragObject, accepted);
Joe Onorato00acb122009-08-04 16:04:30 -0400573 }
574
575 private DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
576 final Rect r = mRectTemp;
577
578 final ArrayList<DropTarget> dropTargets = mDropTargets;
579 final int count = dropTargets.size();
580 for (int i=count-1; i>=0; i--) {
Patrick Dubroy440c3602010-07-13 17:50:32 -0700581 DropTarget target = dropTargets.get(i);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700582 if (!target.isDropEnabled())
583 continue;
584
Joe Onorato00acb122009-08-04 16:04:30 -0400585 target.getHitRect(r);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700586
Adam Cohen8dfcba42011-07-07 16:38:18 -0700587 // Convert the hit rect to DragLayer coordinates
588 target.getLocationInDragLayer(dropCoordinates);
Joe Onorato00acb122009-08-04 16:04:30 -0400589 r.offset(dropCoordinates[0] - target.getLeft(), dropCoordinates[1] - target.getTop());
Patrick Dubroy440c3602010-07-13 17:50:32 -0700590
Adam Cohencb3382b2011-05-24 14:07:08 -0700591 mDragObject.x = x;
592 mDragObject.y = y;
Joe Onorato00acb122009-08-04 16:04:30 -0400593 if (r.contains(x, y)) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700594 DropTarget delegate = target.getDropTargetDelegate(mDragObject);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700595 if (delegate != null) {
596 target = delegate;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700597 target.getLocationInDragLayer(dropCoordinates);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700598 }
599
600 // Make dropCoordinates relative to the DropTarget
Joe Onorato00acb122009-08-04 16:04:30 -0400601 dropCoordinates[0] = x - dropCoordinates[0];
602 dropCoordinates[1] = y - dropCoordinates[1];
Patrick Dubroy440c3602010-07-13 17:50:32 -0700603
Joe Onorato00acb122009-08-04 16:04:30 -0400604 return target;
605 }
606 }
607 return null;
608 }
609
610 public void setDragScoller(DragScroller scroller) {
611 mDragScroller = scroller;
612 }
613
614 public void setWindowToken(IBinder token) {
615 mWindowToken = token;
616 }
617
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800618 /**
619 * Sets the drag listner which will be notified when a drag starts or ends.
620 */
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700621 public void addDragListener(DragListener l) {
622 mListeners.add(l);
Joe Onorato00acb122009-08-04 16:04:30 -0400623 }
624
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800625 /**
626 * Remove a previously installed drag listener.
627 */
Joe Onorato00acb122009-08-04 16:04:30 -0400628 public void removeDragListener(DragListener l) {
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700629 mListeners.remove(l);
Joe Onorato00acb122009-08-04 16:04:30 -0400630 }
631
632 /**
633 * Add a DropTarget to the list of potential places to receive drop events.
634 */
635 public void addDropTarget(DropTarget target) {
636 mDropTargets.add(target);
637 }
638
639 /**
640 * Don't send drop events to <em>target</em> any more.
641 */
642 public void removeDropTarget(DropTarget target) {
643 mDropTargets.remove(target);
644 }
645
646 /**
647 * Set which view scrolls for touch events near the edge of the screen.
648 */
649 public void setScrollView(View v) {
650 mScrollView = v;
651 }
652
653 /**
654 * Specifies the delete region. We won't scroll on touch events over the delete region.
655 *
Adam Cohen8dfcba42011-07-07 16:38:18 -0700656 * @param region The rectangle in DragLayer coordinates of the delete region.
Joe Onorato00acb122009-08-04 16:04:30 -0400657 */
658 void setDeleteRegion(RectF region) {
659 mDeleteRegion = region;
660 }
661
Patrick Dubroy5f445422011-02-18 14:35:21 -0800662 DragView getDragView() {
Adam Cohencb3382b2011-05-24 14:07:08 -0700663 return mDragObject.dragView;
Patrick Dubroy5f445422011-02-18 14:35:21 -0800664 }
665
Joe Onorato00acb122009-08-04 16:04:30 -0400666 private class ScrollRunnable implements Runnable {
667 private int mDirection;
668
669 ScrollRunnable() {
670 }
671
672 public void run() {
673 if (mDragScroller != null) {
674 if (mDirection == SCROLL_LEFT) {
675 mDragScroller.scrollLeft();
676 } else {
677 mDragScroller.scrollRight();
678 }
679 mScrollState = SCROLL_OUTSIDE_ZONE;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700680 mDistanceSinceScroll = 0;
681 mDragScroller.onExitScrollArea();
Joe Onorato00acb122009-08-04 16:04:30 -0400682 }
683 }
684
685 void setDirection(int direction) {
686 mDirection = direction;
687 }
688 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800689}