Android实现3D推拉门式滑动菜单源码解析

<com.example.sliding3dlayout.sliding3dlayout xmlns:android="http://schemas.android.com/apk/res/android"
 xmlns:tools="http://schemas.android.com/tools"
 android:id="@+id/slidinglayout"
 android:layout_width="match_parent"
 android:layout_height="match_parent">
 <relativelayout 
  android:layout_height="fill_parent"
  android:layout_width="240dp"
  android:background="#333333"
  android:visibility="invisible"
  >
  <linearlayout 
   android:layout_centerinparent="true"
   android:layout_width="fill_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   >
   <textview
    android:layout_width="fill_parent"
    android:layout_height="50dp"
    android:text="登录"
    android:gravity="center"
    android:textcolor="#ffffff"
    />
   <textview
    android:layout_width="fill_parent"
    android:layout_height="50dp"
    android:text="注册"
    android:gravity="center"
    android:textcolor="#ffffff"
    />
   <textview
    android:layout_width="fill_parent"
    android:layout_height="50dp"
    android:text="退出"
    android:gravity="center"
    android:textcolor="#ffffff"
    />
  </linearlayout>
 </relativelayout>
 <linearlayout
  android:id="@+id/content"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:layout_alignparentright="true"
  android:background="#ffffff"
  android:orientation="vertical">
  <button
   android:id="@+id/menubutton"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:text="menu" />
  <listview
   android:id="@+id/contentlist"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:cachecolorhint="#00000000" >
  </listview>
 </linearlayout>
</com.example.sliding3dlayout.sliding3dlayout>

public class sliding3dlayout extends relativelayout implements ontouchlistener{

 //滚动显示和隐藏左侧布局时，手指滑动需要达到的速度。
  public static final int snap_velocity = 200;
  //滑动状态的一种，表示未进行任何滑动。
  public static final int do_nothing = 0;
   //滑动状态的一种，表示正在滑出左侧菜单。
  public static final int show_menu = 1;
  //滑动状态的一种，表示正在隐藏左侧菜单。
  public static final int hide_menu = 2;
   //记录当前的滑动状态
  private int slidestate;
   //屏幕宽度值。
  private int screenwidth;
   //右侧布局最多可以滑动到的左边缘。
  private int leftedge = 0;
  //右侧布局最多可以滑动到的右边缘。
  private int rightedge = 0;
  //在被判定为滚动之前用户手指可以移动的最大值。
  private int touchslop;
   //记录手指按下时的横坐标。
  private float xdown;
   //记录手指按下时的纵坐标。
  private float ydown;
   //记录手指移动时的横坐标。
  private float xmove;
  //记录手指移动时的纵坐标。
  private float ymove;
  //记录手机抬起时的横坐标。
  private float xup;
  //左侧布局当前是显示还是隐藏。只有完全显示或隐藏时才会更改此值，滑动过程中此值无效。
  private boolean isleftlayoutvisible;
  //是否正在滑动。
  private boolean issliding;
  //是否已加载过一次layout，这里onlayout中的初始化只需加载一次
  private boolean loadonce;
  //左侧布局对象。
  private view leftlayout;
  //右侧布局对象。
  private view rightlayout;
   //在滑动过程中展示的3d视图
  private image3dview image3dview;
   //用于监听侧滑事件的view。
  private view mbindview;
  //左侧布局的参数，通过此参数来重新确定左侧布局的宽度，以及更改leftmargin的值。
  private marginlayoutparams leftlayoutparams;
  //右侧布局的参数，通过此参数来重新确定右侧布局的宽度。
  private marginlayoutparams rightlayoutparams;
  //3d视图的参数，通过此参数来重新确定3d视图的宽度。
  private viewgroup.layoutparams image3dviewparams;
  //用于计算手指滑动的速度。
  private velocitytracker mvelocitytracker;

 public sliding3dlayout(context context, attributeset attrs){
  super(context, attrs);
  windowmanager wm = (windowmanager) context.getsystemservice(context.window_service);
  screenwidth = wm.getdefaultdisplay().getwidth();
  touchslop = viewconfiguration.get(context).getscaledtouchslop();
 }

 public sliding3dlayout(context context){
  this(context,null);
 }

 /**
  * 左侧布局是否完全显示出来，或完全隐藏，滑动过程中此值无效。
  * @return 左侧布局完全显示返回true，完全隐藏返回false。
  */
 public boolean isleftlayoutvisible(){
  return isleftlayoutvisible;
 }

 /**
  * 绑定监听侧滑事件的view，即在绑定的view进行滑动才可以显示和隐藏左侧布局。
  * @param v
  *  需要绑定的view对象。
  */
 public void setscrollevent(view v){
  mbindview = v;
  mbindview.setontouchlistener(this);
 }

 @override
 public boolean ontouch(view v, motionevent event){
  createvelocitytracker(event);
  switch(event.getaction()){
  case motionevent.action_down:
   xdown = event.getrawx();
   ydown = event.getrawy();
   slidestate = do_nothing ;
   break;
  case motionevent.action_move:
   // 手指移动时，对比按下时的横坐标，计算出移动的距离，来调整右侧布局的leftmargin值，从而显示和隐藏左侧布局
   xmove = event.getrawx();
   ymove = event.getrawy();

   int movedistancex = (int)(xmove - xdown);
   int movedistancey = (int)(ymove - ydown);
   checkslidestate(movedistancex, movedistancey);
   switch(slidestate){
   case show_menu:
    rightlayoutparams.rightmargin = -movedistancex;
    onslide();
    break;
   case hide_menu:
    rightlayoutparams.rightmargin = rightedge - movedistancex;
    onslide();
    break;
    default:
     break;
   }
   break;
  case motionevent.action_up:
   xup = event.getrawx();
   int updistancex = (int)(xup - xdown);
   if(issliding){
    switch (slidestate){
    case show_menu:
     if(shouldscrolltoleftlayout()){
      scrolltoleftlayout();
     }else{
      scrolltorightlayout();
     }
     break;
    case hide_menu:
     if(shouldscrolltorightlayout()){
      scrolltorightlayout();
     }else{
      scrolltoleftlayout();
     }
     break;
    }
   }else if (updistancex < touchslop && isleftlayoutvisible){
    scrolltorightlayout();
   }
   recyclevelocitytracker();
   break;
  }
  if (v.isenabled()){
   if (issliding){
    unfocusbindview();
    return true;
   }
   if (isleftlayoutvisible) {
    return true;
   }
   return false;
  }
  return true;
 }

 @override
 protected void onlayout(boolean changed, int l, int t, int r, int b) {
  super.onlayout(changed, l, t, r, b);
  if(changed&&!loadonce){
   //获取左侧菜单布局
   leftlayout = getchildat(0);
   leftlayoutparams = (marginlayoutparams)leftlayout.getlayoutparams();
   rightedge = -leftlayoutparams.width;

   //获取右侧布局
   rightlayout = getchildat(1);
   rightlayoutparams = (marginlayoutparams)rightlayout.getlayoutparams();
   rightlayoutparams.width = screenwidth;
   rightlayout.setlayoutparams(rightlayoutparams);

   image3dview = new image3dview(getcontext());
   /*viewgroup.layoutparams params = new layoutparams(android.view.viewgroup.layoutparams.wrap_content, 
     android.view.viewgroup.layoutparams.wrap_content);*/
   image3dview.setvisibility(invisible);

   addview(image3dview);
   // 将左侧布局传入3d视图中作为生成源
   image3dview.setsourceview(leftlayout);
   loadonce = true;
  }
 }

 /**
  * 回收velocitytracker对象。
  */
 private void recyclevelocitytracker() {
  mvelocitytracker.recycle();
  mvelocitytracker = null;
 }

 /**
  * 将屏幕滚动到左侧布局界面，滚动速度设定为10.
  */
 public void scrolltoleftlayout(){
  image3dview.clearsourcebitmap();

  new scrolltask().execute(-10);
 }

 /**
  * 将屏幕滚动到右侧布局界面，滚动速度设定为-10.
  */
 public void scrolltorightlayout(){
  image3dview.clearsourcebitmap();
  new scrolltask().execute(10);
 }

 /**
  * 获取手指在右侧布局的监听view上的滑动速度。
  * 
  * @return 滑动速度，以每秒钟移动了多少像素值为单位。
  */
 private int getscrollvelocity() {
  mvelocitytracker.computecurrentvelocity(1000);
  int velocity = (int) mvelocitytracker.getxvelocity();
  return math.abs(velocity);
 }

 /**
  * 判断是否应该滚动将左侧布局展示出来。如果手指移动距离大于屏幕的1/2，或者手指移动速度大于snap_velocity，
  * 就认为应该滚动将左侧布局展示出来。
  * 
  * @return 如果应该滚动将左侧布局展示出来返回true，否则返回false。
  */
 private boolean shouldscrolltoleftlayout() {
  return xup - xdown > leftlayoutparams.width / 2 || getscrollvelocity() > snap_velocity;
 }

 /**
  * 判断是否应该滚动将右侧布局展示出来。如果手指移动距离加上leftlayoutpadding大于屏幕的1/2，
  * 或者手指移动速度大于snap_velocity， 就认为应该滚动将右侧布局展示出来。
  * 
  * @return 如果应该滚动将右侧布局展示出来返回true，否则返回false。
  */
 private boolean shouldscrolltorightlayout(){
  return xdown - xup > leftlayoutparams.width / 2 || getscrollvelocity() > snap_velocity;
 }
 /**
  * 执行滑动过程中的逻辑操作，如边界检查，改变偏移值，可见性检查等。
  */
 private void onslide(){
  checkslideborder();
  rightlayout.setlayoutparams(rightlayoutparams);
  image3dview.clearsourcebitmap();
  image3dviewparams = image3dview.getlayoutparams();
  image3dviewparams.width = -rightlayoutparams.rightmargin;
  //滑动的同时改变3d视图的大小
  image3dview.setlayoutparams(image3dviewparams);
  showimage3dview();
 }

 public void toggle(){
  if(isleftlayoutvisible())
   scrolltorightlayout();
  else
   scrolltoleftlayout();
 }

 /**
  * 保证此时让左侧布局不可见，3d视图可见，从而让滑动过程中产生3d的效果。
  */
 private void showimage3dview() {
  if (image3dview.getvisibility() != view.visible) {
   image3dview.setvisibility(view.visible);
  }
  if (leftlayout.getvisibility() != view.invisible) {
   leftlayout.setvisibility(view.invisible);
  }
 }

 /**
  * 在滑动过程中检查左侧菜单的边界值，防止绑定布局滑出屏幕。
  */
 private void checkslideborder(){
  if (rightlayoutparams.rightmargin > leftedge){
   rightlayoutparams.rightmargin = leftedge;
  } else if (rightlayoutparams.rightmargin < rightedge) {
   rightlayoutparams.rightmargin = rightedge;
  }
 }

 /**
  * 根据手指移动的距离，判断当前用户的滑动意图，然后给slidestate赋值成相应的滑动状态值。
  * 
  * @param movedistancex
  *   横向移动的距离
  * @param movedistancey
  *   纵向移动的距离
  */
 private void checkslidestate(int movedistancex, int movedistancey) {
  if (isleftlayoutvisible) {
   //如果是向左滑动，则是想隐藏菜单
   if (!issliding && math.abs(movedistancex) >= touchslop && movedistancex < 0) {
    issliding = true;
    slidestate = hide_menu;
   }
  }//向右滑动则是显示菜单 
  else if (!issliding && math.abs(movedistancex) >= touchslop && movedistancex > 0
    && math.abs(movedistancey) < touchslop) {
   issliding = true;
   slidestate = show_menu;
  }
 }

 /**
  * 创建velocitytracker对象，并将触摸事件加入到velocitytracker当中。
  * 
  * @param event
  *   右侧布局监听控件的滑动事件
  */
 private void createvelocitytracker(motionevent event) {
  if (mvelocitytracker == null) {
   mvelocitytracker = velocitytracker.obtain();
  }
  mvelocitytracker.addmovement(event);
 }

 class scrolltask extends asynctask<integer, integer, integer>{

  @override
  protected integer doinbackground(integer... speed){
   int rightmargin = rightlayoutparams.rightmargin;
   // 根据传入的速度来滚动界面，当滚动到达左边界或右边界时，跳出循环。
   while(true){
    rightmargin+=speed[0];
    if (rightmargin < rightedge) {
     rightmargin = rightedge;
     break;
    }
    if (rightmargin > leftedge) {
     rightmargin = leftedge;
     break;
    }
    publishprogress(rightmargin);
    // 为了要有滚动效果产生，每次循环使线程睡眠5毫秒，这样肉眼才能够看到滚动动画。
    sleep(5);
   }
   if (speed[0] > 0){
    isleftlayoutvisible = false;
   } else {
    isleftlayoutvisible = true;
   }
   issliding = false;
   return rightmargin;
  }

  @override
  protected void onprogressupdate(integer... rightmargin) {
   rightlayoutparams.rightmargin = rightmargin[0];
   rightlayout.setlayoutparams(rightlayoutparams);
   image3dviewparams = image3dview.getlayoutparams();
   image3dviewparams.width = -rightlayoutparams.rightmargin;
   image3dview.setlayoutparams(image3dviewparams);
   showimage3dview();
   unfocusbindview();
  }

  @override
  protected void onpostexecute(integer rightmargin){
   rightlayoutparams.rightmargin = rightmargin;
   rightlayout.setlayoutparams(rightlayoutparams);
   image3dview.setvisibility(invisible);
   if (isleftlayoutvisible){
    leftlayout.setvisibility(view.visible);
   }
  }

 }

 /**
  * 使用可以获得焦点的控件在滑动的时候失去焦点。
  */
 private void unfocusbindview() {
  if (mbindview != null) {
   mbindview.setpressed(false);
   mbindview.setfocusable(false);
   mbindview.setfocusableintouchmode(false);
  }
 }

 /**
  * 使当前线程睡眠指定的毫秒数。
  * 
  * @param millis
  *   指定当前线程睡眠多久，以毫秒为单位
  */
 private void sleep(long millis) {
  try {
   thread.sleep(millis);
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
 }
}