Left = getLeft();
Right = getRight();
Top = getTop();
Bottom = getBottom();

x = left + translationX;
y = top + translationY;

VelocityTracker velocityTracker = VelocityTracker.obtain();
velocityTracker.addMovement(event);

velocityTracker.computeCurrentVelocity(1000);//1000毫秒
int xVelocity = (int) velocityTracker.getXVelocity();
int yVelocity = (int) velocityTracker.getYVelocity();

velocityTracker.clear();
velocityTracker.recycle();

boolean consume = mGestureDetector.onTouchEvent(event);
return consume;

Scroller scroller = new Scroller(mContext);

//缓慢滚动到指定位置
private void smoothScrollTo(int destX, int destY){
    int scrollX = getScrollX();
    int delta = destX - scrollX;
    //1000ms 内滑向destX，效果就是慢慢滑动
    mScroller.startScroll(scrollX, 0 , delta, 0 ,1000);
    invalidate();
}

@Override
public void computeScroll(){
       if(mScroller.computeScrollOffset()){
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
            postInvalidate();
}

/**
 * Set the scrolled position of your view. This will cause a call to
 * {@link #onScrollChanged(int, int, int, int)} and the view will be
 * invalidated.
 *
 * @param x the x position to scroll to
 * @param y the y position to scroll to
 */
public void scrollTo(int x, int y) {
    if (mScrollX != x || mScrollY != y) {
        int oldX = mScrollX;
        int oldY = mScrollY;
        mScrollX = x;
        mScrollY = y;
        invalidateParentCaches();
        onScrollChanged(mScrollX, mScrollY, oldX, oldY);
        if (!awakenScrollBars()) {
            postInvalidateOnAnimation();
        }
    }
}

/**
 * Move the scrolled position of your view. This will cause a call to
 * {@link #onScrollChanged(int, int, int, int)} and the view will be
 * invalidated.
 *
 * @param x the amount of pixels to scroll by horizontally
 * @param y the amount of pixels to scroll by vertically
 */
public void scrollBy(int x, int y) {
    scrollTo(mScrollX + x, mScrollY + y);
}

MarginLayoutParams params = (MarginLayoutParams)mButton1.getLayoutParams();
params.width += 100;
params.leftMargin += 100;
mButton1.requestLayout();   //或者mButton1.setLayoutParams(params);

//方式二: 动画的方式(改变了translationX, translationY属性)
public class TestButton extends TextView {
    // 分别记录上次滑动的坐标
    private int mLastX = 0;
    private int mLastY = 0;

    public TestButton(Context context) {
        this(context, null);
    }

    public TestButton(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public TestButton(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        final int x = (int) event.getRawX();
        final int y = (int) event.getRawY();
        switch (event.getAction()) {
            case MotionEvent.ACTION_MOVE: {
                final int deltaX = x - mLastX;
                final int deltaY = y - mLastY;
                final int translationX = (int) (super.getTranslationX() + deltaX);
                final int translationY = (int) (super.getTranslationY() + deltaY);
                super.setTranslationX(translationX);
                super.setTranslationY(translationY);
                break;
            }
            default:
                break;
        }
        mLastX = x;
        mLastY = y;
        return true;
    }
}

//方式三: 更改布局的方式
 case MotionEvent.ACTION_MOVE: {
                final int deltaX = x - mLastX;
                final int deltaY = y - mLastY;

                //final int translationX = (int) (super.getTranslationX() + deltaX);
                //final int translationY = (int) (super.getTranslationY() + deltaY);
                //super.setTranslationX(translationX);
                //super.setTranslationY(translationY);

                ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams)getLayoutParams();
                params.leftMargin += deltaX;
                params.topMargin += deltaY;
                requestLayout();

                break;
            }

/**
 * Call this when you want to know the new location.  If it returns true,
 * the animation is not yet finished.
 */
public boolean computeScrollOffset() {
    ...
    int timePassed = (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime);

    if (timePassed < mDuration) {
        switch (mMode) {
            case SCROLL_MODE:
                final float x = mInterpolator.getInterpolation(timePassed * mDurationReciprocal);
                mCurrX = mStartX + Math.round(x * mDeltaX);
                mCurrY = mStartY + Math.round(x * mDeltaY);
                break;
            ...
        }
    }
    ...
    return true;
}

private static final int DELAYED_TIME = 33;

   @SuppressLint("HandlerLeak")
   private Handler mHandler = new Handler() {

       private static final int FRAME_COUNT = 30;
       private static final int DELAY_X = 100; //the x position to scroll to

       private int mCount = 0;

       public void handleMessage(Message msg) {
           mCount++;
           if (mCount <= FRAME_COUNT) {
               float fraction = mCount / (float) FRAME_COUNT;
               int scrollX = (int) (fraction * DELAY_X);
               mButton1.scrollTo(scrollX, 0);
               mHandler.sendEmptyMessageDelayed(0, DELAYED_TIME);
           }
       };
   };

　public boolean dispatchTouchEvent（MotionEvent ev){
　　　　boolean consume = false;
　　　　if(onInterceptTouchEvent(ev)){
　　　　　　consume = onTouchEvent(ev);
　　　　}else{
　　　　　　consume = child.dispatchTouchEvent(ev);
　　　　}
　　　　return consume;
　　}

public boolean onInterceptTouchEvent(MotionEvent event){
    boolean intercepted = false;
    int x = (int) event.getX();
    int y = (int) event.getY();

    switch (event.getAction()){
    case MotionEvent.ACTION_MOVE:{
        if(父容器需要当前点击事件){
            intercepted = true;
        }
        break;
    }
    default:
        break;

    }
    mLastXIntercept = x;
    mLastYIntercept = y;

    return intercepted;

}

public boolean dispathTouchEvent(MotionEvent event){
    int x = (int) event.getX();
    int y = (int) event.getY();

    switch (event.getAction()){
    case MotionEvent.ACTION_DOWN:{
        parent.requestDisallowInterceptTouchEvent(true);
        break;
    }
    case MotionEvent.ACTION_MOVE:{
        int deltaX = x - mLastX;
        int deltaY = y - mLastY;
        if(父容器需要此类点击事件){
            parent.requestDisallowInterceptTouchEvent(false)
        }

        break;
    }
    case MotionEvent.ACTION_UP:{
        break;
    }
    default:
        break;

    }
    mLastX = x;
    mLastY = y;

    return super.dispatchTouchEvent(event);
}

public boolean onInterceptTouchEvent(MotionEvent event){
    if(event.getAction() == MotionEvent.ACTION_DOWN){
        return false;
    }else {
        return true;
    }
}

public class TaskContract {

    /* COMPLETED (1) Add content provider constants to the Contract
     Clients need to know how to access the task data, and it's your job to provide
     these content URI's for the path to that data:
        1) Content authority,
        2) Base content URI,
        3) Path(s) to the tasks directory
        4) Content URI for data in the TaskEntry class
      */

    // The authority, which is how your code knows which Content Provider to access
    public static final String AUTHORITY = "com.example.android.todolist";

    // The base content URI = "content://" + <authority>
    public static final Uri BASE_CONTENT_URI = Uri.parse("content://" + AUTHORITY);

    // Define the possible paths for accessing data in this contract
    // This is the path for the "tasks" directory
    public static final String PATH_TASKS = "tasks";

    /* TaskEntry is an inner class that defines the contents of the task table */
    public static final class TaskEntry implements BaseColumns {

        // TaskEntry content URI = base content URI + path
        public static final Uri CONTENT_URI =
                BASE_CONTENT_URI.buildUpon().appendPath(PATH_TASKS).build();

    ...
    ...
    ...

        /*
        The above table structure looks something like the sample table below.
        With the name of the table and columns on top, and potential contents in rows
        Note: Because this implements BaseColumns, the _id column is generated automatically
        tasks
         - - - - - - - - - - - - - - - - - - - - - -
        | _id  |    description     |    priority   |
         - - - - - - - - - - - - - - - - - - - - - -
        |  1   |  Complete lesson   |       1       |
         - - - - - - - - - - - - - - - - - - - - - -
        |  2   |    Go shopping     |       3       |
         - - - - - - - - - - - - - - - - - - - - - -
        .
        .
        .
         - - - - - - - - - - - - - - - - - - - - - -
        | 43   |   Learn guitar     |       2       |
         - - - - - - - - - - - - - - - - - - - - - -
         */

    }
}

// Verify that TaskContentProvider extends from ContentProvider and implements required methods
public class TaskContentProvider extends ContentProvider {

    // COMPLETED (1) Define final integer constants for the directory of tasks and a single item.
    // It's convention to use 100, 200, 300, etc for directories,
    // and related ints (101, 102, ..) for items in that directory.
    public static final int TASKS = 100;
    public static final int TASK_WITH_ID = 101;

    // COMPLETED (3) Declare a static variable for the Uri matcher that you construct
    private static final UriMatcher sUriMatcher = buildUriMatcher();

    // COMPLETED (2) Define a static buildUriMatcher method that associates URI's with their int match
    /**
     Initialize a new matcher object without any matches,
     then use .addURI(String authority, String path, int match) to add matches
     */
    public static UriMatcher buildUriMatcher() {

        // Initialize a UriMatcher with no matches by passing in NO_MATCH to the constructor
        UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

        /*
          All paths added to the UriMatcher have a corresponding int.
          For each kind of uri you may want to access, add the corresponding match with addURI.
          The two calls below add matches for the task directory and a single item by ID.
         */
        uriMatcher.addURI(TaskContract.AUTHORITY, TaskContract.PATH_TASKS, TASKS);
        uriMatcher.addURI(TaskContract.AUTHORITY, TaskContract.PATH_TASKS + "/#", TASK_WITH_ID);

        return uriMatcher;
    }

    // Member variable for a TaskDbHelper that's initialized in the onCreate() method
    private TaskDbHelper mTaskDbHelper;

    /* onCreate() is where you should initialize anything you’ll need to setup
    your underlying data source.
    In this case, you’re working with a SQLite database, so you’ll need to
    initialize a DbHelper to gain access to it.
     */
    @Override
    public boolean onCreate() {
        // Complete onCreate() and initialize a TaskDbhelper on startup
        // [Hint] Declare the DbHelper as a global variable

        Context context = getContext();
        mTaskDbHelper = new TaskDbHelper(context);
        return true;
    }


    @Override
    public Uri insert(@NonNull Uri uri, ContentValues values) {

        throw new UnsupportedOperationException("Not yet implemented");
    }


    @Override
    public Cursor query(@NonNull Uri uri, String[] projection, String selection,
                        String[] selectionArgs, String sortOrder) {

        throw new UnsupportedOperationException("Not yet implemented");
    }


    @Override
    public int delete(@NonNull Uri uri, String selection, String[] selectionArgs) {

        throw new UnsupportedOperationException("Not yet implemented");
    }


    @Override
    public int update(@NonNull Uri uri, ContentValues values, String selection,
                      String[] selectionArgs) {

        throw new UnsupportedOperationException("Not yet implemented");
    }


    @Override
    public String getType(@NonNull Uri uri) {

        throw new UnsupportedOperationException("Not yet implemented");
    }

}

// Implement insert to handle requests to insert a single new row of data
    @Override
    public Uri insert(@NonNull Uri uri, ContentValues values) {
        // Get access to the task database (to write new data to)
        final SQLiteDatabase db = mTaskDbHelper.getWritableDatabase();

        // Write URI matching code to identify the match for the tasks directory
        int match = sUriMatcher.match(uri);
        Uri returnUri; // URI to be returned

        switch (match) {
            case TASKS:
                // Insert new values into the database
                // Inserting values into tasks table
                long id = db.insert(TABLE_NAME, null, values);
                if ( id > 0 ) {
                    returnUri = ContentUris.withAppendedId(TaskContract.TaskEntry.CONTENT_URI, id);
                } else {
                    throw new android.database.SQLException("Failed to insert row into " + uri);
                }
                break;
            // Set the value for the returnedUri and write the default case for unknown URI's
            // Default case throws an UnsupportedOperationException
            default:
                throw new UnsupportedOperationException("Unknown uri: " + uri);
        }

        // Notify the resolver if the uri has been changed, and return the newly inserted URI
        getContext().getContentResolver().notifyChange(uri, null);

        // Return constructed uri (this points to the newly inserted row of data)
        return returnUri;
    }

// Implement query to handle requests for data by URI
   @Override
   public Cursor query(@NonNull Uri uri, String[] projection, String selection,
                       String[] selectionArgs, String sortOrder) {

       // Get access to underlying database (read-only for query)
       final SQLiteDatabase db = mTaskDbHelper.getReadableDatabase();

       // Write URI match code
       // Write a query for the tasks directory and default case

       int match = sUriMatcher.match(uri);
       Cursor retCursor;

       switch (match) {
           // Query for the tasks directory
           case TASKS:
               retCursor =  db.query(TABLE_NAME,
                       projection,
                       selection,
                       selectionArgs,
                       null,
                       null,
                       sortOrder);
               break;

           // Add a case to query for a single row of data by ID
           // Use selections and selectionArgs to filter for that ID
           case TASK_WITH_ID:
               // Get the id from the URI
               String id = uri.getPathSegments().get(1);

               // Selection is the _ID column = ?, and the Selection args = the row ID from the URI
               String mSelection = "_id=?";
               String[] mSelectionArgs = new String[]{id};

               // Construct a query as you would normally, passing in the selection/args
               retCursor =  db.query(TABLE_NAME,
                       projection,
                       mSelection,
                       mSelectionArgs,
                       null,
                       null,
                       sortOrder);
               break;

           // Default exception
           default:
               throw new UnsupportedOperationException("Unknown uri: " + uri);
       }

       // Set a notification URI on the Cursor
       retCursor.setNotificationUri(getContext().getContentResolver(), uri);

       // Return the desired Cursor
       return retCursor;
   }

// Update won't be used in the final ToDoList app but is implemented here for completeness
   // This updates a single item (by it's ID) in the tasks directory
   @Override
   public int update(@NonNull Uri uri, ContentValues values, String selection,
                     String[] selectionArgs) {

       //Keep track of if an update occurs
       int tasksUpdated;

       // match code
       int match = sUriMatcher.match(uri);

       switch (match) {
           case TASK_WITH_ID:
               //update a single task by getting the id
               String id = uri.getPathSegments().get(1);
               //using selections
               tasksUpdated = mTaskDbHelper.getWritableDatabase().update(TABLE_NAME, values, "_id=?", new String[]{id});
               break;
           default:
               throw new UnsupportedOperationException("Unknown uri: " + uri);
       }

       if (tasksUpdated != 0) {
           //set notifications if a task was updated
           getContext().getContentResolver().notifyChange(uri, null);
       }

       // return number of tasks updated
       return tasksUpdated;
   }

// Implement delete to delete a single row of data
   @Override
   public int delete(@NonNull Uri uri, String selection, String[] selectionArgs) {

       // Get access to the database and write URI matching code to recognize a single item
       final SQLiteDatabase db = mTaskDbHelper.getWritableDatabase();

       int match = sUriMatcher.match(uri);
       // Keep track of the number of deleted tasks
       int tasksDeleted; // starts as 0

       // Write the code to delete a single row of data
       // [Hint] Use selections to delete an item by its row ID
       switch (match) {
           // Handle the single item case, recognized by the ID included in the URI path
           case TASK_WITH_ID:
               // Get the task ID from the URI path
               String id = uri.getPathSegments().get(1);
               // Use selections/selectionArgs to filter for this ID
               tasksDeleted = db.delete(TABLE_NAME, "_id=?", new String[]{id});
               break;
           default:
               throw new UnsupportedOperationException("Unknown uri: " + uri);
       }

       // Notify the resolver of a change and return the number of items deleted
       if (tasksDeleted != 0) {
           // A task was deleted, set notification
           getContext().getContentResolver().notifyChange(uri, null);
       }

       // Return the number of tasks deleted
       return tasksDeleted;
   }

/* getType() handles requests for the MIME type of data
We are working with two types of data:
1) a directory and 2) a single row of data.
This method will not be used in our app, but gives a way to standardize the data formats
that your provider accesses, and this can be useful for data organization.
For now, this method will not be used but will be provided for completeness.
 */
@Override
public String getType(@NonNull Uri uri) {
    int match = sUriMatcher.match(uri);

    switch (match) {
        case TASKS:
            // directory
            return "vnd.android.cursor.dir" + "/" + TaskContract.AUTHORITY + "/" + TaskContract.PATH_TASKS;
        case TASK_WITH_ID:
            // single item type
            return "vnd.android.cursor.item" + "/" + TaskContract.AUTHORITY + "/" + TaskContract.PATH_TASKS;
        default:
            throw new UnsupportedOperationException("Unknown uri: " + uri);
    }
}

package com.example.android.waitlist.data;

import android.provider.BaseColumns;

public class WaitlistContract {

    // COMPLETED (1) Create an inner class named WaitlistEntry class that implements the BaseColumns interface
    public static final class WaitlistEntry implements BaseColumns {
        // COMPLETED (2) Inside create a static final members for the table name and each of the db columns
        public static final String TABLE_NAME = "waitlist";
        public static final String COLUMN_GUEST_NAME = "guestName";
        public static final String COLUMN_PARTY_SIZE = "partySize";
        public static final String COLUMN_TIMESTAMP = "timestamp";
    }

}