Android教程網
設為首頁|加入收藏
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發實例 >> 實戰Android仿人人客戶端之采用ViewGroup做父容器實現左側滑動菜單（三）

實戰Android仿人人客戶端之采用ViewGroup做父容器實現左側滑動菜單（三）

編輯：Android開發實例

        前面已實現以滑動的方式顯示或隱藏左側菜單，采用的父容器是自定義類繼承自RelativeLayout來實現的。看到有網友留言說，采用父容器自定義類繼承自ViewGroup去實現，這篇我就講解下采用繼承自ViewGroup的方式去如何實現。

        自定義類讓其繼承自ViewGroup類後，編譯器強制添加一個帶Context類型參數的構造方法和onLayout()方法，代碼如下：

  1. package com.everyone.android.widget;  
  2.  
  3. import android.content.Context;  
  4. import android.view.View;  
  5. import android.view.ViewGroup;  
  6.  
  7. /**  
  8.  * 功能描述：手指在屏幕上左右滑動時，該類的實例負責讓其子View根據用戶的手勢左右偏移（滾動）  
  9.  * 父容器采用ViewGroup  
  10.  * @author android_ls  
  11.  */ 
  12. public class HorizontalScrollerContainer extends ViewGroup {  
  13.  
  14.     public HorizontalScrollerContainer(Context context) {  
  15.         super(context);  
  16.     }  
  17.      
  18.     @Override 
  19.     protected void onLayout(boolean changed, int l, int t, int r, int b) {        }  
  20.  
  21. }  

          通過閱讀上面的代碼片段，引發的思考，ViewGroup類有無參構造方法嗎？答案是沒有；至於onLayout()方法，肯定是一個抽象方法了，那麼ViewGroup類肯定是抽象類。在Java的繼承體系中，父類（ViewGroup）中有抽象方法，子類繼承父類必須（強制性的）去實現父類的抽象方法或者把自己也定義成抽象的。既然onLayout()方法是抽象方法，我們自定義的類去繼承了ViewGroup類，最後自定義的類是要用來誕生對象的，那肯定不能也定義成抽象的。我們就去實現它，代碼如下：

  1. @Override 
  2.   protected void onLayout(boolean changed, int l, int t, int r, int b) {  
  3.       int childCount = getChildCount();  
  4.       for (int i = 0; i < childCount; i++) {  
  5.           View child = getChildAt(i);  
  6.           child.layout(0, 0, child.getMeasuredWidth(), child.getMeasuredHeight());  
  7.       }  
  8.   }  

       既然容器有了，我們就向其中添加子View，在Activity的onCreate()方法添加如下代碼：

  1. // 父容器  
  2.  HorizontalScrollerContainer mSlideContainer = new HorizontalScrollerContainer(mContext);  
  3.    
  4.  // 左側面板  
  5.  LeftPanelLayout mLeftPanelLayout = new LeftPanelLayout(mContext);  
  6.  LayoutParams layoutParams = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);  
  7.  // 添加子View  
  8.  mSlideContainer.addView(mLeftPanelLayout, layoutParams);  
  9.    
  10.  // 設置要顯示的視圖  
  11.  setContentView(mSlideContainer);  

       我們運行程序，效果圖如下：



       看到這張效果圖，有人可能要說，我們自定義的父容器HorizontalScrollerContainer類的對象，到底有沒有設置到Window（哪來的Window對象呢？查看過Android源碼的朋友肯定知道，沒翻過源碼的見這行： getWindow().setContentView(view)，這不是重點。）上，我們為父容器添加一張背景圖，代碼如下：

  1. public HorizontalScrollerContainer(Context context) {  
  2.       super(context);  
  3.       this.setBackgroundResource(R.drawable.v5_3_0_guide_pic1);  
  4.   }  

運行效果圖：

 


        通過上面的驗證，說明我們的父容器View是已添加到PhoneWindow上了，只是其中的子View沒有顯示出來。如何才能讓父容器中的子View顯示出來呢? 我們還得去重寫父容器ViewGroup的onMeasure(int widthMeasureSpec, int heightMeasureSpec)方法，代碼如下：

  1. @Override 
  2.   protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  3.       super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
  4.       int childCount = getChildCount();  
  5.       for (int i = 0; i < childCount; i++) {  
  6.           getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);  
  7.       }  
  8.   }  

       運行看效果：

 


        這次明顯達到了我們的預期（目的），效果是實現了，到底為什麼之前沒達到預期效果呢，應用框架層明明強制我（自定義類繼承自ViewGroup類）去實現的只有onLayout()方法，我按你（應用框架）的要求去做了，為什麼達不到預期效果呢？

       當你為一個Activty 的PhoneWindow設置一個可見的View（ViewGroup），並且運行這個Activty時，應用框架層的調用（控制反轉）ViewGroup的顯示視圖相關方法的順序：onAttachedToWindow-->onMeasure-->onSizeChanged-->onLayout（注：其它相關的方法我們不關注，這裡就沒列出來）。下面來解釋下這幾個我們關注的方法的含義：

        1、onAttachedToWindow：當View附加到一個窗體上時，應用框架層調用此方法。

        2、onMeasure：View自己調用此方法，測量自己及其子View的實際寬度和高度。

        3、onSizeChanged：當View大小改變時，調用此方法

        4、onLayout：View自己調用此方法，為所有子View分配顯示空間的大小，可能會與子View定義時設置的大小不一樣。比如：父容器是LinearLayout，裡面的子View排列方向是豎直方式，我向父容器中添加第一個子View（A），設置寬度為fill_parent，高度為50dip；我再向父容器中添加第二個子View（B），設置寬度為fill_parent，高度也為fill_parent。在這種情況下，子View（B）的高度為多少？ 是fill_parent嗎？肯定不是啦，是父容器的高度減去子View（A）的高度。（可能會與子View定義時設置的大小不一樣）

          我的個人觀點：既然編寫自定義類去繼承ViewGroup後，子類必須去實現onMeasure(int widthMeasureSpec, int heightMeasureSpec)方法，為什麼不把onMeasure()方法在ViewGroup類中定義成抽象的呢？翻看源碼，會發現：

onMeasure()是定義在View類中的，源碼如下：

  1. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  2.      setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
  3.              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
  4.  }  

         ViewGroup類完全可以重寫父類的onMeasure()方法，將其修改成抽象方法。那麼當我們想自定義類去繼承ViwGroup類，都會去實現onMeasure()方法，就不會出現按應用框架要求的去做，而沒達到預期的，我們想要的結果。

       編寫兩個類，進行測試，TestA類源碼：

 

  1. package com.everyone.android.widget;  
  2.  
  3. public class TestA {   
  4.       
  5.  public void test(){  
  6.      System.out.println("Hello World");  
  7.  }   
  8.    
  9. }  

       TestB類源碼：

  1. package com.everyone.android.widget;  
  2.  
  3. public abstract class TestB extends TestA{  
  4.     public abstract void test();  
  5. }  
  6.  

        通過上面的測試，大家看到這麼寫，子類是可以修改父類的方法修飾詞的。

       假如：Android應用框架裡，ViewGroup類裡重寫了父類的onMeasure()方法，在ViewGroup類中添加如下代碼：

  1. protected abstract void onMeasure(int widthMeasureSpec, int heightMeasureSpec);  

        我們自已的類繼承ViewGroup後，我們實現onMeasure()方法的代碼如下：

  1. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  2.       int width = MeasureSpec.getSize(widthMeasureSpec);  
  3.       int height = MeasureSpec.getSize(heightMeasureSpec);  
  4.       setMeasuredDimension(width, height);  
  5.         
  6.       int childCount = getChildCount();  
  7.       for (int i = 0; i < childCount; i++) {  
  8.           getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);  
  9.       }  
  10.   }  

          至於Android應用框架層為什麼沒按我們預想的那樣去實現，自然有他們的道理，呵呵。我個人覺的若在子類中必須重寫父類的某個方法後，才既能滿足框架層又能讓使用框架的達到預期的效果。干嘛不把該方法定義成抽象的呢？何樂而不為。
        好了，到這裡這一篇的重點聊完了。其它的關於用戶觸摸屏幕事件的分發、攔截和處理（響應）與前面的采用RelativeLayout做父容器時是一樣的。

        采用ViewGroup做父容器，實現水平滑動顯示或隱藏左側菜單的完整代碼如下：

 

  1. package com.everyone.android.widget;  
  2.  
  3. import android.content.Context;  
  4. import android.util.Log;  
  5. import android.util.TypedValue;  
  6. import android.view.MotionEvent;  
  7. import android.view.VelocityTracker;  
  8. import android.view.View;  
  9. import android.view.ViewConfiguration;  
  10. import android.view.ViewGroup;  
  11. import android.widget.Scroller;  
  12.  
  13. /**  
  14.  * 功能描述：手指在屏幕上左右滑動時，該類的實例負責讓其子View根據用戶的手勢左右偏移（滾動）  
  15.  * 父容器采用ViewGroup  
  16.  * @author android_ls  
  17.  */ 
  18. public class HorizontalScrollerContainer extends ViewGroup {  
  19.  
  20.     private static final String TAG = "ScrollerContainer";  
  21.  
  22.     private Scroller mScroller;  
  23.  
  24.     private VelocityTracker mVelocityTracker;  
  25.  
  26.     /**  
  27.      * 手柄（手把）的寬度  
  28.      */ 
  29.     private int mHandlebarWidth;  
  30.  
  31.     /**  
  32.      * 在偏移過程中，動畫持續的時間  
  33.      */ 
  34.     private static final int ANIMATION_DURATION_TIME = 300;  
  35.       
  36.     /**  
  37.      * 記錄當前的滑動結束後的狀態，左側面板是否可見  
  38.      * true  向右滑動（左側面板處於可見）  
  39.      * false 向左滑動（左側面板處於不可見）  
  40.      */ 
  41.     private boolean mPanelInvisible;  
  42.       
  43.     /**  
  44.      * 是否已滑動結束  
  45.      */ 
  46.     private boolean mFinished;  
  47.       
  48.     /**  
  49.      * 是否允許滾動  
  50.      * 滿足的條件：  
  51.      *     左側面板可見，當前手指按下的坐標x值 ，是在手柄寬度范圍內；  
  52.      *     左側面板不可見，當前手指按下的坐標x值 < 手柄寬度  
  53.      */ 
  54.     private boolean mAllowScroll;  
  55.       
  56.     /**  
  57.      * 是否滿足響應單擊事件的條件  
  58.      * 滿足的條件：左側面板可見，當前手指按下的坐標x值 ，是在手柄寬度范圍內  
  59.      */ 
  60.     private boolean isClick;  
  61.       
  62.     public HorizontalScrollerContainer(Context context) {  
  63.         super(context);  
  64.         // this.setBackgroundResource(R.drawable.v5_3_0_guide_pic1);  
  65.           
  66.         mScroller = new Scroller(context);  
  67.         mHandlebarWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 70, getResources().getDisplayMetrics());  
  68.     }  
  69.       
  70.     // 測量自己及其子View的實際寬度和高度  
  71.     @Override 
  72.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  73.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
  74.         int childCount = getChildCount();  
  75.         for (int i = 0; i < childCount; i++) {  
  76.             getChildAt(i).measure(widthMeasureSpec, heightMeasureSpec);  
  77.         }  
  78.     }  
  79.       
  80.     /*  
  81.      * 為所有子View分配顯示空間的大小 ，可能會與子View定義時設置的大小不一樣。  
  82.      * 比如：父容器是LinearLayout，裡面的子View排列方向是豎直方式，我向父容器中添加第一個子View（A），  
  83.      * 設置寬度為fill_parent，高度為50dip；我再向父容器中添加第二個子View（B），設置寬度為fill_parent，高度也為fill_parent。  
  84.      * 在這種情況下，子View（B）的高度為多少？ 是fill_parent嗎？肯定不是啦，是父容器的高度減去子View（A）的高度。  
  85.      * （可能會與子View定義時設置的大小不一樣）  
  86.      * @see android.view.ViewGroup#onLayout(boolean, int, int, int, int)  
  87.      */ 
  88.     @Override 
  89.     protected void onLayout(boolean changed, int l, int t, int r, int b) {  
  90.         int childCount = getChildCount();  
  91.         for (int i = 0; i < childCount; i++) {  
  92.             View child = getChildAt(i);  
  93.             child.layout(0, 0, child.getMeasuredWidth(), child.getMeasuredHeight());  
  94.         }  
  95.     }  
  96.       
  97.     @Override 
  98.     public boolean dispatchTouchEvent(MotionEvent ev) {  
  99.         Log.e(TAG, "dispatchTouchEvent()");  
  100.           
  101.         switch (ev.getAction()) {  
  102.         case MotionEvent.ACTION_DOWN:  
  103.             Log.i(TAG, "dispatchTouchEvent():  ACTION_DOWN");  
  104.               
  105.             mFinished = mScroller.isFinished();  
  106.             if(mFinished){  
  107.                 int x = (int) ev.getX();  
  108.                 int width = getWidth();  
  109.                   
  110.                 if(mPanelInvisible)// 左側面板可見  
  111.                 {  
  112.                     if(x > (width - mHandlebarWidth)){ // 當前手指按下的坐標x值 ，是在手柄寬度范圍內  
  113.                         isClick = true;  
  114.                         mAllowScroll = true;  
  115.                         return true;  
  116.                     } else {  
  117.                         isClick = false;  
  118.                         mAllowScroll = false;  
  119.                     }  
  120.                 } else { // 左側面板不可見  
  121.                     if(x < mHandlebarWidth ){ // 當前手指按下的坐標x值 < 手柄寬度 （也就是說在手柄寬度范圍內，是可以相應用戶的向右滑動手勢）  
  122.                         mAllowScroll = true;  
  123.                     }else{  
  124.                         mAllowScroll = false;  
  125.                     }  
  126.                 }  
  127.                   
  128.             } else {  
  129.                 // 當前正在滾動子View，其它的事不響應  
  130.                 return false;  
  131.             }  
  132.               
  133.             break;  
  134.  
  135.         case MotionEvent.ACTION_MOVE:  
  136.             Log.i(TAG, "dispatchTouchEvent():  ACTION_MOVE");  
  137.             int margin = getWidth() - (int) ev.getX();  
  138.             if (margin < mHandlebarWidth && mAllowScroll) {  
  139.                   
  140.                 Log.e(TAG, "dispatchTouchEvent ACTION_MOVE margin = " + margin + "\t mHandlebarWidth = " + mHandlebarWidth);  
  141.                 return true;  
  142.             }  
  143.               
  144.             break;  
  145.         case MotionEvent.ACTION_UP:  
  146.             Log.i(TAG, "dispatchTouchEvent():  ACTION_UP");  
  147.               
  148.             if (isClick && mPanelInvisible && mAllowScroll) {  
  149.                 isClick = false;  
  150.                 mPanelInvisible = false;  
  151.                   
  152.                 int scrollX = getChildAt(1).getScrollX();  
  153.                 mScroller.startScroll(scrollX, 0, -scrollX, 0, ANIMATION_DURATION_TIME);  
  154.                 invalidate();  
  155.                   
  156.                 return true;  
  157.             }  
  158.               
  159.             break;  
  160.         case MotionEvent.ACTION_CANCEL:  
  161.             Log.i(TAG, "dispatchTouchEvent():  ACTION_CANCEL");  
  162.             break;  
  163.         default:  
  164.             break;  
  165.         }  
  166.           
  167.         return super.dispatchTouchEvent(ev);  
  168.     }  
  169.       
  170.     @Override 
  171.     public boolean onInterceptTouchEvent(MotionEvent ev) {  
  172.         Log.e(TAG, "onInterceptTouchEvent()");  
  173.           
  174.         switch (ev.getAction()) {  
  175.         case MotionEvent.ACTION_DOWN:  
  176.             Log.i(TAG, "onInterceptTouchEvent():  ACTION_DOWN");  
  177.             mFinished = mScroller.isFinished();  
  178.             if(!mFinished){  
  179.                 return false;  
  180.             }  
  181.               
  182.             break;  
  183.         case MotionEvent.ACTION_MOVE:  
  184.             Log.i(TAG, "onInterceptTouchEvent():  ACTION_MOVE");  
  185.               
  186.             mVelocityTracker = VelocityTracker.obtain();  
  187.             mVelocityTracker.addMovement(ev);  
  188.               
  189.             // 一秒時間內移動了多少個像素  
  190.             mVelocityTracker.computeCurrentVelocity(1000, ViewConfiguration.getMaximumFlingVelocity());  
  191.             float velocityValue = Math.abs(mVelocityTracker.getXVelocity()) ;  
  192.             Log.d(TAG, "onInterceptTouchEvent():  mVelocityValue = " + velocityValue);  
  193.               
  194.             if (velocityValue > 300 && mAllowScroll) {  
  195.                 return true;  
  196.             }  
  197.               
  198.             break;  
  199.         case MotionEvent.ACTION_UP:  
  200.             Log.i(TAG, "onInterceptTouchEvent():  ACTION_UP");  
  201.               
  202.             if (mVelocityTracker != null) {  
  203.                 mVelocityTracker.recycle();  
  204.                 mVelocityTracker = null;  
  205.             }  
  206.               
  207.             break;  
  208.         case MotionEvent.ACTION_CANCEL:  
  209.             Log.i(TAG, "onInterceptTouchEvent():  ACTION_CANCEL");  
  210.             break;  
  211.         default:  
  212.             break;  
  213.         }  
  214.           
  215.         return super.onInterceptTouchEvent(ev);  
  216.     }  
  217.  
  218.     @Override 
  219.     public boolean onTouchEvent(MotionEvent event) {  
  220.         Log.e(TAG, "onTouchEvent()");  
  221.  
  222.         float x = event.getX();  
  223.           
  224.         switch (event.getAction()) {  
  225.         case MotionEvent.ACTION_DOWN:  
  226.             Log.i(TAG, "onTouchEvent():  ACTION_DOWN");  
  227.             mFinished = mScroller.isFinished();  
  228.             if(!mFinished){  
  229.                 return false;  
  230.             }  
  231.             break;  
  232.  
  233.         case MotionEvent.ACTION_MOVE:  
  234.             Log.i(TAG, "onTouchEvent():  ACTION_MOVE");  
  235.             getChildAt(1).scrollTo(-(int)x, 0);  
  236.             break;  
  237.  
  238.         case MotionEvent.ACTION_UP:  
  239.             Log.i(TAG, "onTouchEvent():  ACTION_UP");  
  240.               
  241.             if(!mAllowScroll){  
  242.                 break;  
  243.             }  
  244.               
  245.            float width = getWidth();  
  246.            // 響應滾動子View的臨界值，若覺得響應過於靈敏，可以將只改大些。  
  247.            // 比如：criticalWidth = width / 3或criticalWidth = width / 2，看情況而定，呵呵。  
  248.            float criticalWidth = width / 5;  
  249.              
  250.            Log.i(TAG, "onTouchEvent():  ACTION_UP x = " + x + "\t criticalWidth = " + criticalWidth);  
  251.              
  252.            int scrollX = getChildAt(1).getScrollX();  
  253.              
  254.            if ( x < criticalWidth) {  
  255.                Log.i(TAG, "onTouchEvent():  ACTION_UP 向左滑動");  
  256.                  
  257.                 mPanelInvisible = false;  
  258.                  
  259.                 mScroller.startScroll(scrollX, 0, -scrollX, 0, ANIMATION_DURATION_TIME);  
  260.                 invalidate();  
  261.             } else if ( x > criticalWidth){  
  262.                 Log.i(TAG, "onTouchEvent():  ACTION_UP 向右滑動");  
  263.                 
  264.                 mPanelInvisible = true;  
  265.                   
  266.                 int toX = (int)(width - Math.abs(scrollX) - mHandlebarWidth);  
  267.                 mScroller.startScroll(scrollX, 0, -toX, 0, ANIMATION_DURATION_TIME);  
  268.                 invalidate();  
  269.             }  
  270.               
  271.             break;  
  272.         case MotionEvent.ACTION_CANCEL:  
  273.             Log.i(TAG, "onTouchEvent():  ACTION_CANCEL");  
  274.             break;  
  275.         default:  
  276.             break;  
  277.         }  
  278.           
  279.         return super.onTouchEvent(event);  
  280.     }  
  281.  
  282.     @Override 
  283.     public void computeScroll() {  
  284.         // super.computeScroll();  
  285.           
  286.         if(mScroller.computeScrollOffset()){  
  287.             this.getChildAt(1).scrollTo(mScroller.getCurrX(), mScroller.getCurrY());  
  288.             this.postInvalidate();  
  289.         }  
  290.     }  
  291.  
  292.     /**  
  293.      * 向右滑動View，讓左側操作面飯可見  
  294.      */ 
  295.     public void slideToRight() {  
  296.         mFinished = mScroller.isFinished();  
  297.         if(mFinished && !mPanelInvisible){  
  298.             mPanelInvisible = true;  
  299.               
  300.             float width = getWidth();  
  301.             int scrollX = getChildAt(1).getScrollX();  
  302.             int toX = (int)(width - Math.abs(scrollX) - mHandlebarWidth);  
  303.               
  304.             mScroller.startScroll(scrollX, 0, -toX, 0, ANIMATION_DURATION_TIME);  
  305.             invalidate();  
  306.         }  
  307.     }  
  308.       
  309.     /**  
  310.      * View滑動事件監聽器  
  311.      * @author android_ls  
  312.      */ 
  313.     public interface OnSlideListener {  
  314.         /**  
  315.          * 向左滑動子View  
  316.          */ 
  317.         public abstract void toLeft();  
  318.           
  319.         /**  
  320.          * 向右滑動子View  
  321.          */ 
  322.         public abstract void toRight();  
  323.     }  
  324.       
  325. }  
  326.  

      測試的Activity源碼如下：

  1. package com.everyone.android.ui;  
  2.  
  3. import android.os.Bundle;  
  4. import android.view.ViewGroup.LayoutParams;  
  5.  
  6. import com.everyone.android.AppBaseActivity;  
  7. import com.everyone.android.widget.FreshNewsLayout;  
  8. import com.everyone.android.widget.HorizontalScrollerContainer;  
  9. import com.everyone.android.widget.HorizontalScrollerContainer.OnSlideListener;  
  10. import com.everyone.android.widget.LeftPanelLayout;  
  11.  
  12. /**  
  13.  * 功能描述：應用主界面  
  14.  * @author android_ls  
  15.  *  
  16.  */ 
  17. public class EveryoneActivity extends AppBaseActivity implements OnSlideListener {  
  18.  
  19.     /**  
  20.      * 滾動（滑動）容器  
  21.      */ 
  22.     private HorizontalScrollerContainer mSlideContainer;  
  23.  
  24.     /**  
  25.      * 左側面板  
  26.      */ 
  27.     private LeftPanelLayout mLeftPanelLayout;  
  28.  
  29.     /**  
  30.      * 新鮮事  
  31.      */ 
  32.     private FreshNewsLayout mFreshNewsLayout;  
  33.  
  34.     @Override 
  35.     public void onCreate(Bundle savedInstanceState) {  
  36.         super.onCreate(savedInstanceState);  
  37.         setContentView(mSlideContainer);  
  38.          
  39.     }  
  40.  
  41.     @Override 
  42.     protected int getLayoutId() {  
  43.         return 0;  
  44.     }  
  45.  
  46.     @Override 
  47.     protected void setupView() {  
  48.         mSlideContainer = new HorizontalScrollerContainer(mContext);  
  49.  
  50.         mLeftPanelLayout = new LeftPanelLayout(mContext);  
  51.         mFreshNewsLayout = new FreshNewsLayout(mContext);  
  52.         mFreshNewsLayout.setOnSlideListener(this);  
  53.  
  54.         LayoutParams layoutParams = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);  
  55.         mSlideContainer.addView(mLeftPanelLayout, layoutParams);  
  56.         mSlideContainer.addView(mFreshNewsLayout, layoutParams);  
  57.     }  
  58.  
  59.     @Override 
  60.     protected void initialized() {  
  61.         // TODO Auto-generated method stub  
  62.  
  63.     }  
  64.  
  65.     @Override 
  66.     public void toLeft() {  
  67.         // TODO Auto-generated method stub  
  68.  
  69.     }  
  70.  
  71.     @Override 
  72.     public void toRight() {  
  73.         mSlideContainer.slideToRight();  
  74.     }  
  75.  
  76. }  

       運行效果圖：

 

 

轉自：http://blog.csdn.net/android_ls/article/details/8761410

  1. 上一頁:
  2. 下一頁:
Android開發實例
Android編程入門Android技術基礎Android資訊關於Android編程Android開發Android開發環境Android開發實例
相關文章
熱門文章
Android本地化 android Content Provider詳解四 android編程判斷應用是否具有某個權限的方法 Android應用開發入門（五十九）MediaPlayer的高級功能應用 Android藍牙開發實例解析 Android Service的使用及介紹（二）
Android編程之OpenGL繪圖技巧總結

本文實例講述了Android編程之OpenGL繪圖技巧。分享給大
Android高級開發之性能優化典范

本章介紹android高級開發中，對於性能方面的處理。主要包括電
Android中庫項目的使用方法圖文介紹

在軟件開發過程中，程序代碼的復用，是非常重要的概念。我們總是需要
Android本地化

Android應用程序可以在許多不同地區的許多設備上運行。為了使應用程序
閱讀排行版
Copyright © Android教程網 All Rights Reserved