blob: f2db48726f6d9e3b89f7260c4bd68db1a6d5698c [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;
Winson Chungb8c69f32011-10-19 21:36:08 -070021import android.graphics.Point;
Winson Chung043f2af2012-03-01 16:09:54 -080022import android.graphics.PointF;
Joe Onorato00acb122009-08-04 16:04:30 -040023import android.graphics.Rect;
Joe Onorato00acb122009-08-04 16:04:30 -040024import android.os.Handler;
Michael Jurka0280c3b2010-09-17 15:00:07 -070025import android.os.IBinder;
Joe Onorato00acb122009-08-04 16:04:30 -040026import android.os.Vibrator;
Joe Onorato00acb122009-08-04 16:04:30 -040027import android.util.Log;
Joe Onorato00acb122009-08-04 16:04:30 -040028import android.view.KeyEvent;
29import android.view.MotionEvent;
Winson Chung043f2af2012-03-01 16:09:54 -080030import android.view.VelocityTracker;
Michael Jurka0280c3b2010-09-17 15:00:07 -070031import android.view.View;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -070032import android.view.ViewConfiguration;
Joe Onorato00acb122009-08-04 16:04:30 -040033import android.view.inputmethod.InputMethodManager;
Joe Onorato00acb122009-08-04 16:04:30 -040034
Adam Cohen120980b2010-12-08 11:05:37 -080035import com.android.launcher.R;
Adam Cohenc0dcf592011-06-01 15:30:43 -070036
37import java.util.ArrayList;
The Android Open Source Project31dd5032009-03-03 19:32:27 -080038
39/**
Joe Onorato00acb122009-08-04 16:04:30 -040040 * Class for initiating a drag within a view or across multiple views.
The Android Open Source Project31dd5032009-03-03 19:32:27 -080041 */
Joe Onorato00acb122009-08-04 16:04:30 -040042public class DragController {
Romain Guyea3763c2010-01-11 18:02:04 -080043 @SuppressWarnings({"UnusedDeclaration"})
Joe Onorato2e5c4322009-10-06 12:34:42 -070044 private static final String TAG = "Launcher.DragController";
45
Joe Onorato00acb122009-08-04 16:04:30 -040046 /** Indicates the drag is a move. */
47 public static int DRAG_ACTION_MOVE = 0;
48
49 /** Indicates the drag is a copy. */
50 public static int DRAG_ACTION_COPY = 1;
51
Winson Chungaa15ffe2012-01-18 15:45:28 -080052 private static final int SCROLL_DELAY = 500;
53 private static final int RESCROLL_DELAY = 750;
Winson Chung61b0c692012-02-23 16:31:13 -080054 private static final int VIBRATE_DURATION = 15;
Joe Onorato00acb122009-08-04 16:04:30 -040055
56 private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
57
58 private static final int SCROLL_OUTSIDE_ZONE = 0;
59 private static final int SCROLL_WAITING_IN_ZONE = 1;
60
Patrick Dubroy54fa3b92010-11-17 12:18:45 -080061 static final int SCROLL_NONE = -1;
Patrick Dubroy1262e362010-10-06 15:49:50 -070062 static final int SCROLL_LEFT = 0;
63 static final int SCROLL_RIGHT = 1;
Joe Onorato00acb122009-08-04 16:04:30 -040064
Winson Chung043f2af2012-03-01 16:09:54 -080065 private static final float MAX_FLING_DEGREES = 35f;
Winson Chung9658b1e2012-04-09 18:30:07 -070066 private static final int FLING_TO_DELETE_THRESHOLD_Y_VELOCITY = -1500;
Winson Chung043f2af2012-03-01 16:09:54 -080067
Adam Cohen8dfcba42011-07-07 16:38:18 -070068 private Launcher mLauncher;
Joe Onorato00acb122009-08-04 16:04:30 -040069 private Handler mHandler;
70 private final Vibrator mVibrator = new Vibrator();
71
72 // temporaries to avoid gc thrash
73 private Rect mRectTemp = new Rect();
74 private final int[] mCoordinatesTemp = new int[2];
75
76 /** Whether or not we're dragging. */
77 private boolean mDragging;
78
79 /** X coordinate of the down event. */
Adam Cohene3e27a82011-04-15 12:07:39 -070080 private int mMotionDownX;
Joe Onorato00acb122009-08-04 16:04:30 -040081
82 /** Y coordinate of the down event. */
Adam Cohene3e27a82011-04-15 12:07:39 -070083 private int mMotionDownY;
Joe Onorato00acb122009-08-04 16:04:30 -040084
Joe Onorato658db742010-09-29 11:40:39 -070085 /** the area at the edge of the screen that makes the workspace go left
86 * or right while you're dragging.
87 */
88 private int mScrollZone;
89
Adam Cohen9932a9b2011-08-02 22:14:07 -070090 private DropTarget.DragObject mDragObject;
Joe Onorato00acb122009-08-04 16:04:30 -040091
92 /** Who can receive drop events */
93 private ArrayList<DropTarget> mDropTargets = new ArrayList<DropTarget>();
Patrick Dubroy4ed62782010-08-17 15:11:18 -070094 private ArrayList<DragListener> mListeners = new ArrayList<DragListener>();
Winson Chung043f2af2012-03-01 16:09:54 -080095 private DropTarget mFlingToDeleteDropTarget;
Joe Onorato00acb122009-08-04 16:04:30 -040096
97 /** The window token used as the parent for the DragView. */
98 private IBinder mWindowToken;
99
100 /** The view that will be scrolled when dragging to the left and right edges of the screen. */
101 private View mScrollView;
102
Romain Guyea3763c2010-01-11 18:02:04 -0800103 private View mMoveTarget;
104
Joe Onorato00acb122009-08-04 16:04:30 -0400105 private DragScroller mDragScroller;
106 private int mScrollState = SCROLL_OUTSIDE_ZONE;
107 private ScrollRunnable mScrollRunnable = new ScrollRunnable();
108
Joe Onorato00acb122009-08-04 16:04:30 -0400109 private DropTarget mLastDropTarget;
110
111 private InputMethodManager mInputMethodManager;
112
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700113 private int mLastTouch[] = new int[2];
Winson Chung318eee02012-04-12 10:59:27 -0700114 private long mLastTouchUpTime = -1;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700115 private int mDistanceSinceScroll = 0;
116
Winson Chung273c1022011-07-11 13:40:52 -0700117 private int mTmpPoint[] = new int[2];
118 private Rect mDragLayerRect = new Rect();
119
Winson Chung043f2af2012-03-01 16:09:54 -0800120 protected int mFlingToDeleteThresholdVelocity;
121 private VelocityTracker mVelocityTracker;
122
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800123 /**
124 * Interface to receive notifications when a drag starts or stops
125 */
126 interface DragListener {
127
128 /**
129 * A drag has begun
130 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800131 * @param source An object representing where the drag originated
132 * @param info The data associated with the object that is being dragged
133 * @param dragAction The drag action: either {@link DragController#DRAG_ACTION_MOVE}
134 * or {@link DragController#DRAG_ACTION_COPY}
135 */
Joe Onorato5162ea92009-09-03 09:39:42 -0700136 void onDragStart(DragSource source, Object info, int dragAction);
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800137
138 /**
Winson Chunge3193b92010-09-10 11:44:42 -0700139 * The drag has ended
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800140 */
141 void onDragEnd();
142 }
143
144 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400145 * Used to create a new DragLayer from XML.
146 *
147 * @param context The application's context.
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800148 */
Adam Cohen8dfcba42011-07-07 16:38:18 -0700149 public DragController(Launcher launcher) {
150 mLauncher = launcher;
Joe Onorato00acb122009-08-04 16:04:30 -0400151 mHandler = new Handler();
Adam Cohen8dfcba42011-07-07 16:38:18 -0700152 mScrollZone = launcher.getResources().getDimensionPixelSize(R.dimen.scroll_zone);
Winson Chung043f2af2012-03-01 16:09:54 -0800153 mVelocityTracker = VelocityTracker.obtain();
154
155 float density = launcher.getResources().getDisplayMetrics().density;
156 mFlingToDeleteThresholdVelocity = (int) (FLING_TO_DELETE_THRESHOLD_Y_VELOCITY * density);
Joe Onorato00acb122009-08-04 16:04:30 -0400157 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800158
Patrick Dubroy1262e362010-10-06 15:49:50 -0700159 public boolean dragging() {
160 return mDragging;
161 }
162
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800163 /**
Joe Onorato5162ea92009-09-03 09:39:42 -0700164 * Starts a drag.
Michael Jurkaa63c4522010-08-19 13:52:27 -0700165 *
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800166 * @param v The view that is being dragged
167 * @param source An object representing where the drag originated
Romain Guyea3763c2010-01-11 18:02:04 -0800168 * @param dragInfo The data associated with the object that is being dragged
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800169 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
170 * {@link #DRAG_ACTION_COPY}
171 */
Joe Onorato00acb122009-08-04 16:04:30 -0400172 public void startDrag(View v, DragSource source, Object dragInfo, int dragAction) {
Michael Jurkaa63c4522010-08-19 13:52:27 -0700173 startDrag(v, source, dragInfo, dragAction, null);
174 }
175
176 /**
177 * Starts a drag.
178 *
179 * @param v The view that is being dragged
180 * @param source An object representing where the drag originated
181 * @param dragInfo The data associated with the object that is being dragged
182 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
183 * {@link #DRAG_ACTION_COPY}
184 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
185 * Makes dragging feel more precise, e.g. you can clip out a transparent border
186 */
187 public void startDrag(View v, DragSource source, Object dragInfo, int dragAction,
188 Rect dragRegion) {
Joe Onorato5162ea92009-09-03 09:39:42 -0700189 Bitmap b = getViewBitmap(v);
190
Daniel Sandler3f8175a2010-05-25 11:48:32 -0400191 if (b == null) {
192 // out of memory?
193 return;
194 }
195
Joe Onorato5162ea92009-09-03 09:39:42 -0700196 int[] loc = mCoordinatesTemp;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700197 mLauncher.getDragLayer().getLocationInDragLayer(v, loc);
198 int dragLayerX = loc[0];
199 int dragLayerY = loc[1];
Joe Onorato5162ea92009-09-03 09:39:42 -0700200
Winson Chung72d59842012-02-22 13:51:36 -0800201 startDrag(b, dragLayerX, dragLayerY, source, dragInfo, dragAction, null, dragRegion, 1f);
Joe Onorato5162ea92009-09-03 09:39:42 -0700202 b.recycle();
203
204 if (dragAction == DRAG_ACTION_MOVE) {
205 v.setVisibility(View.GONE);
206 }
207 }
208
209 /**
210 * Starts a drag.
Michael Jurkaa63c4522010-08-19 13:52:27 -0700211 *
Winson Chunge3193b92010-09-10 11:44:42 -0700212 * @param v The view that is being dragged
213 * @param bmp The bitmap that represents the view being dragged
214 * @param source An object representing where the drag originated
215 * @param dragInfo The data associated with the object that is being dragged
216 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
217 * {@link #DRAG_ACTION_COPY}
218 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
219 * Makes dragging feel more precise, e.g. you can clip out a transparent border
220 */
221 public void startDrag(View v, Bitmap bmp, DragSource source, Object dragInfo, int dragAction,
Winson Chung72d59842012-02-22 13:51:36 -0800222 Rect dragRegion, float initialDragViewScale) {
Winson Chunge3193b92010-09-10 11:44:42 -0700223 int[] loc = mCoordinatesTemp;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700224 mLauncher.getDragLayer().getLocationInDragLayer(v, loc);
Winson Chung72d59842012-02-22 13:51:36 -0800225 int dragLayerX = loc[0] + v.getPaddingLeft() +
226 (int) ((initialDragViewScale * bmp.getWidth() - bmp.getWidth()) / 2);
227 int dragLayerY = loc[1] + v.getPaddingTop() +
228 (int) ((initialDragViewScale * bmp.getHeight() - bmp.getHeight()) / 2);
Winson Chunge3193b92010-09-10 11:44:42 -0700229
Winson Chung72d59842012-02-22 13:51:36 -0800230 startDrag(bmp, dragLayerX, dragLayerY, source, dragInfo, dragAction, null, dragRegion,
231 initialDragViewScale);
Winson Chunge3193b92010-09-10 11:44:42 -0700232
233 if (dragAction == DRAG_ACTION_MOVE) {
234 v.setVisibility(View.GONE);
235 }
236 }
237
238 /**
239 * Starts a drag.
240 *
Joe Onorato5162ea92009-09-03 09:39:42 -0700241 * @param b The bitmap to display as the drag image. It will be re-scaled to the
242 * enlarged size.
Adam Cohen8dfcba42011-07-07 16:38:18 -0700243 * @param dragLayerX The x position in the DragLayer of the left-top of the bitmap.
244 * @param dragLayerY The y position in the DragLayer of the left-top of the bitmap.
Joe Onorato5162ea92009-09-03 09:39:42 -0700245 * @param source An object representing where the drag originated
Romain Guyea3763c2010-01-11 18:02:04 -0800246 * @param dragInfo The data associated with the object that is being dragged
Joe Onorato5162ea92009-09-03 09:39:42 -0700247 * @param dragAction The drag action: either {@link #DRAG_ACTION_MOVE} or
248 * {@link #DRAG_ACTION_COPY}
Michael Jurkaa63c4522010-08-19 13:52:27 -0700249 * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
250 * Makes dragging feel more precise, e.g. you can clip out a transparent border
251 */
Adam Cohen8dfcba42011-07-07 16:38:18 -0700252 public void startDrag(Bitmap b, int dragLayerX, int dragLayerY,
Winson Chung72d59842012-02-22 13:51:36 -0800253 DragSource source, Object dragInfo, int dragAction, Point dragOffset, Rect dragRegion,
254 float initialDragViewScale) {
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,
Winson Chung72d59842012-02-22 13:51:36 -0800289 registrationY, 0, 0, b.getWidth(), b.getHeight(), initialDragViewScale);
Michael Jurkaa63c4522010-08-19 13:52:27 -0700290
Winson Chungb8c69f32011-10-19 21:36:08 -0700291 if (dragOffset != null) {
292 dragView.setDragVisualizeOffset(new Point(dragOffset));
293 }
Michael Jurkaa63c4522010-08-19 13:52:27 -0700294 if (dragRegion != null) {
Adam Cohene3e27a82011-04-15 12:07:39 -0700295 dragView.setDragRegion(new Rect(dragRegion));
Michael Jurkaa63c4522010-08-19 13:52:27 -0700296 }
297
Adam Cohen8dfcba42011-07-07 16:38:18 -0700298 dragView.show(mMotionDownX, mMotionDownY);
299 handleMoveEvent(mMotionDownX, mMotionDownY);
Joe Onorato00acb122009-08-04 16:04:30 -0400300 }
301
302 /**
303 * Draw the view into a bitmap.
304 */
Adam Cohen120980b2010-12-08 11:05:37 -0800305 Bitmap getViewBitmap(View v) {
Joe Onorato00acb122009-08-04 16:04:30 -0400306 v.clearFocus();
307 v.setPressed(false);
308
309 boolean willNotCache = v.willNotCacheDrawing();
310 v.setWillNotCacheDrawing(false);
311
312 // Reset the drawing cache background color to fully transparent
313 // for the duration of this operation
314 int color = v.getDrawingCacheBackgroundColor();
315 v.setDrawingCacheBackgroundColor(0);
Adam Cohen120980b2010-12-08 11:05:37 -0800316 float alpha = v.getAlpha();
317 v.setAlpha(1.0f);
Joe Onorato00acb122009-08-04 16:04:30 -0400318
319 if (color != 0) {
320 v.destroyDrawingCache();
321 }
322 v.buildDrawingCache();
323 Bitmap cacheBitmap = v.getDrawingCache();
Daniel Sandler3f8175a2010-05-25 11:48:32 -0400324 if (cacheBitmap == null) {
325 Log.e(TAG, "failed getViewBitmap(" + v + ")", new RuntimeException());
326 return null;
327 }
Joe Onorato00acb122009-08-04 16:04:30 -0400328
329 Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);
330
331 // Restore the view
332 v.destroyDrawingCache();
Adam Cohen120980b2010-12-08 11:05:37 -0800333 v.setAlpha(alpha);
Joe Onorato00acb122009-08-04 16:04:30 -0400334 v.setWillNotCacheDrawing(willNotCache);
335 v.setDrawingCacheBackgroundColor(color);
336
337 return bitmap;
338 }
339
340 /**
341 * Call this from a drag source view like this:
342 *
343 * <pre>
344 * @Override
345 * public boolean dispatchKeyEvent(KeyEvent event) {
346 * return mDragController.dispatchKeyEvent(this, event)
347 * || super.dispatchKeyEvent(event);
348 * </pre>
349 */
Romain Guyea3763c2010-01-11 18:02:04 -0800350 @SuppressWarnings({"UnusedDeclaration"})
Joe Onorato00acb122009-08-04 16:04:30 -0400351 public boolean dispatchKeyEvent(KeyEvent event) {
352 return mDragging;
353 }
354
Winson Chung304dcde2011-01-07 11:17:23 -0800355 public boolean isDragging() {
356 return mDragging;
357 }
358
Joe Onorato24b6fd82009-11-12 13:47:09 -0800359 /**
360 * Stop dragging without dropping.
361 */
362 public void cancelDrag() {
Winson Chung621e6402011-01-04 16:03:57 -0800363 if (mDragging) {
Winson Chungc07918d2011-07-01 15:35:26 -0700364 if (mLastDropTarget != null) {
365 mLastDropTarget.onDragExit(mDragObject);
366 }
Winson Chung41bb19d2012-03-05 18:36:46 -0800367 mDragObject.deferDragViewCleanupPostAnimation = false;
Adam Cohen36cc09b2011-09-29 17:33:15 -0700368 mDragObject.cancelled = true;
Adam Cohenbfbfd262011-06-13 16:55:12 -0700369 mDragObject.dragComplete = true;
Winson Chunga48487a2012-03-20 16:19:37 -0700370 mDragObject.dragSource.onDropCompleted(null, mDragObject, false, false);
Winson Chung621e6402011-01-04 16:03:57 -0800371 }
Joe Onorato24b6fd82009-11-12 13:47:09 -0800372 endDrag();
373 }
Winson Chunga1820962011-10-03 16:31:06 -0700374 public void onAppsRemoved(ArrayList<ApplicationInfo> apps, Context context) {
375 // Cancel the current drag if we are removing an app that we are dragging
376 if (mDragObject != null) {
377 Object rawDragInfo = mDragObject.dragInfo;
378 if (rawDragInfo instanceof ShortcutInfo) {
379 ShortcutInfo dragInfo = (ShortcutInfo) rawDragInfo;
380 for (ApplicationInfo info : apps) {
Michael Jurka7bcadad2012-04-02 07:23:44 -0700381 // Added null checks to prevent NPE we've seen in the wild
382 if (dragInfo != null &&
383 dragInfo.intent != null &&
384 info.intent != null &&
385 dragInfo.intent.getComponent().equals(info.intent.getComponent())) {
Winson Chunga1820962011-10-03 16:31:06 -0700386 cancelDrag();
387 return;
388 }
389 }
390 }
391 }
392 }
Joe Onorato24b6fd82009-11-12 13:47:09 -0800393
Joe Onorato00acb122009-08-04 16:04:30 -0400394 private void endDrag() {
395 if (mDragging) {
396 mDragging = false;
Winson Chungaa15ffe2012-01-18 15:45:28 -0800397 clearScrollRunnable();
Winson Chung043f2af2012-03-01 16:09:54 -0800398 boolean isDeferred = false;
Adam Cohencb3382b2011-05-24 14:07:08 -0700399 if (mDragObject.dragView != null) {
Winson Chung043f2af2012-03-01 16:09:54 -0800400 isDeferred = mDragObject.deferDragViewCleanupPostAnimation;
401 if (!isDeferred) {
Winson Chung7bd1bbb2012-02-13 18:29:29 -0800402 mDragObject.dragView.remove();
403 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700404 mDragObject.dragView = null;
Joe Onorato00acb122009-08-04 16:04:30 -0400405 }
Winson Chung043f2af2012-03-01 16:09:54 -0800406
407 // Only end the drag if we are not deferred
408 if (!isDeferred) {
409 for (DragListener listener : mListeners) {
410 listener.onDragEnd();
411 }
412 }
413 }
414
415 releaseVelocityTracker();
416 }
417
418 /**
419 * This only gets called as a result of drag view cleanup being deferred in endDrag();
420 */
421 void onDeferredEndDrag(DragView dragView) {
422 dragView.remove();
423
424 // If we skipped calling onDragEnd() before, do it now
425 for (DragListener listener : mListeners) {
426 listener.onDragEnd();
Joe Onorato00acb122009-08-04 16:04:30 -0400427 }
428 }
429
Winson Chunga48487a2012-03-20 16:19:37 -0700430 void onDeferredEndFling(DropTarget.DragObject d) {
431 d.dragSource.onFlingToDeleteCompleted();
432 }
433
Joe Onorato00acb122009-08-04 16:04:30 -0400434 /**
Winson Chung273c1022011-07-11 13:40:52 -0700435 * Clamps the position to the drag layer bounds.
436 */
437 private int[] getClampedDragLayerPos(float x, float y) {
438 mLauncher.getDragLayer().getLocalVisibleRect(mDragLayerRect);
439 mTmpPoint[0] = (int) Math.max(mDragLayerRect.left, Math.min(x, mDragLayerRect.right - 1));
440 mTmpPoint[1] = (int) Math.max(mDragLayerRect.top, Math.min(y, mDragLayerRect.bottom - 1));
441 return mTmpPoint;
442 }
443
Winson Chunga2413752012-04-03 14:22:34 -0700444 long getLastGestureUpTime() {
445 if (mDragging) {
446 return System.currentTimeMillis();
447 } else {
448 return mLastTouchUpTime;
449 }
450 }
451
452 void resetLastGestureUpTime() {
453 mLastTouchUpTime = -1;
454 }
455
Winson Chung273c1022011-07-11 13:40:52 -0700456 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400457 * Call this from a drag source view.
458 */
459 public boolean onInterceptTouchEvent(MotionEvent ev) {
Joe Onorato9c1289c2009-08-17 11:03:03 -0400460 if (false) {
Joe Onoratoa30ce8e2009-11-11 08:16:49 -0800461 Log.d(Launcher.TAG, "DragController.onInterceptTouchEvent " + ev + " mDragging="
Joe Onorato9c1289c2009-08-17 11:03:03 -0400462 + mDragging);
463 }
Joe Onorato00acb122009-08-04 16:04:30 -0400464
Winson Chung043f2af2012-03-01 16:09:54 -0800465 // Update the velocity tracker
466 acquireVelocityTrackerAndAddMovement(ev);
467
468 final int action = ev.getAction();
Winson Chung273c1022011-07-11 13:40:52 -0700469 final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
470 final int dragLayerX = dragLayerPos[0];
471 final int dragLayerY = dragLayerPos[1];
Joe Onorato00acb122009-08-04 16:04:30 -0400472
473 switch (action) {
474 case MotionEvent.ACTION_MOVE:
475 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400476 case MotionEvent.ACTION_DOWN:
477 // Remember location of down touch
Adam Cohen8dfcba42011-07-07 16:38:18 -0700478 mMotionDownX = dragLayerX;
479 mMotionDownY = dragLayerY;
Joe Onorato00acb122009-08-04 16:04:30 -0400480 mLastDropTarget = null;
481 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400482 case MotionEvent.ACTION_UP:
Winson Chunga2413752012-04-03 14:22:34 -0700483 mLastTouchUpTime = System.currentTimeMillis();
Joe Onorato00acb122009-08-04 16:04:30 -0400484 if (mDragging) {
Winson Chung043f2af2012-03-01 16:09:54 -0800485 PointF vec = isFlingingToDelete(mDragObject.dragSource);
486 if (vec != null) {
487 dropOnFlingToDeleteTarget(dragLayerX, dragLayerY, vec);
488 } else {
489 drop(dragLayerX, dragLayerY);
490 }
Joe Onorato00acb122009-08-04 16:04:30 -0400491 }
492 endDrag();
493 break;
Winson Chung621e6402011-01-04 16:03:57 -0800494 case MotionEvent.ACTION_CANCEL:
495 cancelDrag();
496 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400497 }
498
499 return mDragging;
500 }
501
502 /**
Romain Guyea3763c2010-01-11 18:02:04 -0800503 * Sets the view that should handle move events.
504 */
505 void setMoveTarget(View view) {
506 mMoveTarget = view;
507 }
508
509 public boolean dispatchUnhandledMove(View focused, int direction) {
510 return mMoveTarget != null && mMoveTarget.dispatchUnhandledMove(focused, direction);
511 }
512
Winson Chungaa15ffe2012-01-18 15:45:28 -0800513 private void clearScrollRunnable() {
514 mHandler.removeCallbacks(mScrollRunnable);
515 if (mScrollState == SCROLL_WAITING_IN_ZONE) {
516 mScrollState = SCROLL_OUTSIDE_ZONE;
517 mScrollRunnable.setDirection(SCROLL_RIGHT);
518 mDragScroller.onExitScrollArea();
519 }
520 }
521
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700522 private void handleMoveEvent(int x, int y) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700523 mDragObject.dragView.move(x, y);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700524
525 // Drop on someone?
526 final int[] coordinates = mCoordinatesTemp;
527 DropTarget dropTarget = findDropTarget(x, y, coordinates);
Adam Cohencb3382b2011-05-24 14:07:08 -0700528 mDragObject.x = coordinates[0];
529 mDragObject.y = coordinates[1];
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700530 if (dropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700531 DropTarget delegate = dropTarget.getDropTargetDelegate(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700532 if (delegate != null) {
533 dropTarget = delegate;
534 }
535
536 if (mLastDropTarget != dropTarget) {
537 if (mLastDropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700538 mLastDropTarget.onDragExit(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700539 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700540 dropTarget.onDragEnter(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700541 }
Adam Cohencb3382b2011-05-24 14:07:08 -0700542 dropTarget.onDragOver(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700543 } else {
544 if (mLastDropTarget != null) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700545 mLastDropTarget.onDragExit(mDragObject);
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700546 }
547 }
548 mLastDropTarget = dropTarget;
549
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700550 // After a scroll, the touch point will still be in the scroll region.
551 // Rather than scrolling immediately, require a bit of twiddling to scroll again
Adam Cohen8dfcba42011-07-07 16:38:18 -0700552 final int slop = ViewConfiguration.get(mLauncher).getScaledWindowTouchSlop();
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700553 mDistanceSinceScroll +=
554 Math.sqrt(Math.pow(mLastTouch[0] - x, 2) + Math.pow(mLastTouch[1] - y, 2));
555 mLastTouch[0] = x;
556 mLastTouch[1] = y;
Winson Chungaa15ffe2012-01-18 15:45:28 -0800557 final int delay = mDistanceSinceScroll < slop ? RESCROLL_DELAY : SCROLL_DELAY;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700558
Winson Chung3f4e1422011-11-17 14:58:51 -0800559 if (x < mScrollZone) {
Winson Chungaa15ffe2012-01-18 15:45:28 -0800560 if (mScrollState == SCROLL_OUTSIDE_ZONE) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700561 mScrollState = SCROLL_WAITING_IN_ZONE;
Winson Chung3e0839e2011-10-03 15:15:18 -0700562 if (mDragScroller.onEnterScrollArea(x, y, SCROLL_LEFT)) {
563 mScrollRunnable.setDirection(SCROLL_LEFT);
Winson Chungaa15ffe2012-01-18 15:45:28 -0800564 mHandler.postDelayed(mScrollRunnable, delay);
Winson Chung3e0839e2011-10-03 15:15:18 -0700565 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700566 }
Winson Chung3f4e1422011-11-17 14:58:51 -0800567 } else if (x > mScrollView.getWidth() - mScrollZone) {
Winson Chungaa15ffe2012-01-18 15:45:28 -0800568 if (mScrollState == SCROLL_OUTSIDE_ZONE) {
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700569 mScrollState = SCROLL_WAITING_IN_ZONE;
Winson Chung3e0839e2011-10-03 15:15:18 -0700570 if (mDragScroller.onEnterScrollArea(x, y, SCROLL_RIGHT)) {
571 mScrollRunnable.setDirection(SCROLL_RIGHT);
Winson Chungaa15ffe2012-01-18 15:45:28 -0800572 mHandler.postDelayed(mScrollRunnable, delay);
Winson Chung3e0839e2011-10-03 15:15:18 -0700573 }
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700574 }
575 } else {
Winson Chungaa15ffe2012-01-18 15:45:28 -0800576 clearScrollRunnable();
Patrick Dubroyde7658b2010-09-27 11:15:43 -0700577 }
578 }
579
Winson Chung3bc21c32012-01-20 13:59:18 -0800580 public void forceMoveEvent() {
581 if (mDragging) {
582 handleMoveEvent(mDragObject.x, mDragObject.y);
583 }
584 }
585
Romain Guyea3763c2010-01-11 18:02:04 -0800586 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400587 * Call this from a drag source view.
588 */
589 public boolean onTouchEvent(MotionEvent ev) {
Joe Onorato00acb122009-08-04 16:04:30 -0400590 if (!mDragging) {
591 return false;
592 }
593
Winson Chung043f2af2012-03-01 16:09:54 -0800594 // Update the velocity tracker
595 acquireVelocityTrackerAndAddMovement(ev);
596
Joe Onorato00acb122009-08-04 16:04:30 -0400597 final int action = ev.getAction();
Winson Chung273c1022011-07-11 13:40:52 -0700598 final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
599 final int dragLayerX = dragLayerPos[0];
600 final int dragLayerY = dragLayerPos[1];
Joe Onorato00acb122009-08-04 16:04:30 -0400601
602 switch (action) {
603 case MotionEvent.ACTION_DOWN:
Joe Onorato00acb122009-08-04 16:04:30 -0400604 // Remember where the motion event started
Adam Cohen8dfcba42011-07-07 16:38:18 -0700605 mMotionDownX = dragLayerX;
606 mMotionDownY = dragLayerY;
Joe Onorato00acb122009-08-04 16:04:30 -0400607
Adam Cohen8dfcba42011-07-07 16:38:18 -0700608 if ((dragLayerX < mScrollZone) || (dragLayerX > mScrollView.getWidth() - mScrollZone)) {
Joe Onorato00acb122009-08-04 16:04:30 -0400609 mScrollState = SCROLL_WAITING_IN_ZONE;
610 mHandler.postDelayed(mScrollRunnable, SCROLL_DELAY);
611 } else {
612 mScrollState = SCROLL_OUTSIDE_ZONE;
613 }
Joe Onorato00acb122009-08-04 16:04:30 -0400614 break;
615 case MotionEvent.ACTION_MOVE:
Adam Cohen8dfcba42011-07-07 16:38:18 -0700616 handleMoveEvent(dragLayerX, dragLayerY);
Joe Onorato00acb122009-08-04 16:04:30 -0400617 break;
618 case MotionEvent.ACTION_UP:
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800619 // Ensure that we've processed a move event at the current pointer location.
Adam Cohen8dfcba42011-07-07 16:38:18 -0700620 handleMoveEvent(dragLayerX, dragLayerY);
Winson Chung3bc21c32012-01-20 13:59:18 -0800621 mHandler.removeCallbacks(mScrollRunnable);
Winson Chung043f2af2012-03-01 16:09:54 -0800622
Joe Onorato00acb122009-08-04 16:04:30 -0400623 if (mDragging) {
Winson Chung043f2af2012-03-01 16:09:54 -0800624 PointF vec = isFlingingToDelete(mDragObject.dragSource);
625 if (vec != null) {
626 dropOnFlingToDeleteTarget(dragLayerX, dragLayerY, vec);
627 } else {
628 drop(dragLayerX, dragLayerY);
629 }
Joe Onorato00acb122009-08-04 16:04:30 -0400630 }
631 endDrag();
Joe Onorato00acb122009-08-04 16:04:30 -0400632 break;
633 case MotionEvent.ACTION_CANCEL:
Winson Chung3bc21c32012-01-20 13:59:18 -0800634 mHandler.removeCallbacks(mScrollRunnable);
Joe Onorato24b6fd82009-11-12 13:47:09 -0800635 cancelDrag();
Winson Chung621e6402011-01-04 16:03:57 -0800636 break;
Joe Onorato00acb122009-08-04 16:04:30 -0400637 }
638
639 return true;
640 }
641
Winson Chung043f2af2012-03-01 16:09:54 -0800642 /**
643 * Determines whether the user flung the current item to delete it.
644 *
645 * @return the vector at which the item was flung, or null if no fling was detected.
646 */
647 private PointF isFlingingToDelete(DragSource source) {
648 if (mFlingToDeleteDropTarget == null) return null;
649 if (!source.supportsFlingToDelete()) return null;
650
651 ViewConfiguration config = ViewConfiguration.get(mLauncher);
652 mVelocityTracker.computeCurrentVelocity(1000, config.getScaledMaximumFlingVelocity());
653
654 if (mVelocityTracker.getYVelocity() < mFlingToDeleteThresholdVelocity) {
655 // Do a quick dot product test to ensure that we are flinging upwards
656 PointF vel = new PointF(mVelocityTracker.getXVelocity(),
657 mVelocityTracker.getYVelocity());
658 PointF upVec = new PointF(0f, -1f);
659 float theta = (float) Math.acos(((vel.x * upVec.x) + (vel.y * upVec.y)) /
660 (vel.length() * upVec.length()));
661 if (theta <= Math.toRadians(MAX_FLING_DEGREES)) {
662 return vel;
663 }
664 }
665 return null;
666 }
667
668 private void dropOnFlingToDeleteTarget(float x, float y, PointF vel) {
669 final int[] coordinates = mCoordinatesTemp;
670
671 mDragObject.x = coordinates[0];
672 mDragObject.y = coordinates[1];
Winson Chung043f2af2012-03-01 16:09:54 -0800673
674 // Clean up dragging on the target if it's not the current fling delete target otherwise,
675 // start dragging to it.
676 if (mLastDropTarget != null && mFlingToDeleteDropTarget != mLastDropTarget) {
677 mLastDropTarget.onDragExit(mDragObject);
678 }
679
680 // Drop onto the fling-to-delete target
681 boolean accepted = false;
682 mFlingToDeleteDropTarget.onDragEnter(mDragObject);
Winson Chung232decb2012-03-28 15:09:05 -0700683 // We must set dragComplete to true _only_ after we "enter" the fling-to-delete target for
684 // "drop"
685 mDragObject.dragComplete = true;
Winson Chung043f2af2012-03-01 16:09:54 -0800686 mFlingToDeleteDropTarget.onDragExit(mDragObject);
687 if (mFlingToDeleteDropTarget.acceptDrop(mDragObject)) {
688 mFlingToDeleteDropTarget.onFlingToDelete(mDragObject, mDragObject.x, mDragObject.y,
689 vel);
690 accepted = true;
691 }
Winson Chunga48487a2012-03-20 16:19:37 -0700692 mDragObject.dragSource.onDropCompleted((View) mFlingToDeleteDropTarget, mDragObject, true,
Winson Chung043f2af2012-03-01 16:09:54 -0800693 accepted);
694 }
695
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800696 private void drop(float x, float y) {
Joe Onorato00acb122009-08-04 16:04:30 -0400697 final int[] coordinates = mCoordinatesTemp;
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800698 final DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);
Joe Onorato00acb122009-08-04 16:04:30 -0400699
Adam Cohencb3382b2011-05-24 14:07:08 -0700700 mDragObject.x = coordinates[0];
701 mDragObject.y = coordinates[1];
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800702 boolean accepted = false;
Joe Onorato00acb122009-08-04 16:04:30 -0400703 if (dropTarget != null) {
Adam Cohenbfbfd262011-06-13 16:55:12 -0700704 mDragObject.dragComplete = true;
Adam Cohencb3382b2011-05-24 14:07:08 -0700705 dropTarget.onDragExit(mDragObject);
706 if (dropTarget.acceptDrop(mDragObject)) {
707 dropTarget.onDrop(mDragObject);
Patrick Dubroyb0a6bbe2011-03-02 18:40:21 -0800708 accepted = true;
Joe Onorato00acb122009-08-04 16:04:30 -0400709 }
710 }
Winson Chunga48487a2012-03-20 16:19:37 -0700711 mDragObject.dragSource.onDropCompleted((View) dropTarget, mDragObject, false, accepted);
Joe Onorato00acb122009-08-04 16:04:30 -0400712 }
713
714 private DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
715 final Rect r = mRectTemp;
716
717 final ArrayList<DropTarget> dropTargets = mDropTargets;
718 final int count = dropTargets.size();
719 for (int i=count-1; i>=0; i--) {
Patrick Dubroy440c3602010-07-13 17:50:32 -0700720 DropTarget target = dropTargets.get(i);
Michael Jurka0280c3b2010-09-17 15:00:07 -0700721 if (!target.isDropEnabled())
722 continue;
723
Joe Onorato00acb122009-08-04 16:04:30 -0400724 target.getHitRect(r);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700725
Adam Cohen8dfcba42011-07-07 16:38:18 -0700726 // Convert the hit rect to DragLayer coordinates
727 target.getLocationInDragLayer(dropCoordinates);
Joe Onorato00acb122009-08-04 16:04:30 -0400728 r.offset(dropCoordinates[0] - target.getLeft(), dropCoordinates[1] - target.getTop());
Patrick Dubroy440c3602010-07-13 17:50:32 -0700729
Adam Cohencb3382b2011-05-24 14:07:08 -0700730 mDragObject.x = x;
731 mDragObject.y = y;
Joe Onorato00acb122009-08-04 16:04:30 -0400732 if (r.contains(x, y)) {
Adam Cohencb3382b2011-05-24 14:07:08 -0700733 DropTarget delegate = target.getDropTargetDelegate(mDragObject);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700734 if (delegate != null) {
735 target = delegate;
Adam Cohen8dfcba42011-07-07 16:38:18 -0700736 target.getLocationInDragLayer(dropCoordinates);
Patrick Dubroy440c3602010-07-13 17:50:32 -0700737 }
738
739 // Make dropCoordinates relative to the DropTarget
Joe Onorato00acb122009-08-04 16:04:30 -0400740 dropCoordinates[0] = x - dropCoordinates[0];
741 dropCoordinates[1] = y - dropCoordinates[1];
Patrick Dubroy440c3602010-07-13 17:50:32 -0700742
Joe Onorato00acb122009-08-04 16:04:30 -0400743 return target;
744 }
745 }
746 return null;
747 }
748
749 public void setDragScoller(DragScroller scroller) {
750 mDragScroller = scroller;
751 }
752
753 public void setWindowToken(IBinder token) {
754 mWindowToken = token;
755 }
756
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800757 /**
758 * Sets the drag listner which will be notified when a drag starts or ends.
759 */
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700760 public void addDragListener(DragListener l) {
761 mListeners.add(l);
Joe Onorato00acb122009-08-04 16:04:30 -0400762 }
763
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800764 /**
765 * Remove a previously installed drag listener.
766 */
Joe Onorato00acb122009-08-04 16:04:30 -0400767 public void removeDragListener(DragListener l) {
Patrick Dubroy4ed62782010-08-17 15:11:18 -0700768 mListeners.remove(l);
Joe Onorato00acb122009-08-04 16:04:30 -0400769 }
770
771 /**
772 * Add a DropTarget to the list of potential places to receive drop events.
773 */
774 public void addDropTarget(DropTarget target) {
775 mDropTargets.add(target);
776 }
777
778 /**
779 * Don't send drop events to <em>target</em> any more.
780 */
781 public void removeDropTarget(DropTarget target) {
782 mDropTargets.remove(target);
783 }
784
785 /**
Winson Chung043f2af2012-03-01 16:09:54 -0800786 * Sets the current fling-to-delete drop target.
787 */
788 public void setFlingToDeleteDropTarget(DropTarget target) {
789 mFlingToDeleteDropTarget = target;
790 }
791
792 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) {
793 if (mVelocityTracker == null) {
794 mVelocityTracker = VelocityTracker.obtain();
795 }
796 mVelocityTracker.addMovement(ev);
797 }
798
799 private void releaseVelocityTracker() {
800 if (mVelocityTracker != null) {
801 mVelocityTracker.recycle();
802 mVelocityTracker = null;
803 }
804 }
805
806 /**
Joe Onorato00acb122009-08-04 16:04:30 -0400807 * Set which view scrolls for touch events near the edge of the screen.
808 */
809 public void setScrollView(View v) {
810 mScrollView = v;
811 }
812
Patrick Dubroy5f445422011-02-18 14:35:21 -0800813 DragView getDragView() {
Adam Cohencb3382b2011-05-24 14:07:08 -0700814 return mDragObject.dragView;
Patrick Dubroy5f445422011-02-18 14:35:21 -0800815 }
816
Joe Onorato00acb122009-08-04 16:04:30 -0400817 private class ScrollRunnable implements Runnable {
818 private int mDirection;
819
820 ScrollRunnable() {
821 }
822
823 public void run() {
824 if (mDragScroller != null) {
825 if (mDirection == SCROLL_LEFT) {
826 mDragScroller.scrollLeft();
827 } else {
828 mDragScroller.scrollRight();
829 }
830 mScrollState = SCROLL_OUTSIDE_ZONE;
Patrick Dubroya16fd5a2010-10-07 16:47:28 -0700831 mDistanceSinceScroll = 0;
832 mDragScroller.onExitScrollArea();
Winson Chungaa15ffe2012-01-18 15:45:28 -0800833
834 if (isDragging()) {
835 // Force an update so that we can requeue the scroller if necessary
Winson Chung3bc21c32012-01-20 13:59:18 -0800836 forceMoveEvent();
Winson Chungaa15ffe2012-01-18 15:45:28 -0800837 }
Joe Onorato00acb122009-08-04 16:04:30 -0400838 }
839 }
840
841 void setDirection(int direction) {
842 mDirection = direction;
843 }
844 }
The Android Open Source Project31dd5032009-03-03 19:32:27 -0800845}