viewgroup_自定义viewgroup - CSDN
精华内容
参与话题
  • ViewGroup的使用

    千次阅读 2018-05-14 08:38:15
    View类 1,android.view类是个最基本的UI类,android上很多UI组件都是继承此类而实现的。 2,这些UI组件包括Button(按钮), TextView(文本框),CheckBox(选...ViewGroup类 1,上面所说的UI组件是放置到一个专...

    View类

    1,android.view类是个最基本的UI类,android上很多UI组件都是继承此类而实现的。

    2,这些UI组件包括Button(按钮), TextView(文本框),CheckBox(选字框)等等。

    3,那么这些UI组件应该怎么放置呢?

    ViewGroup类

    1,上面所说的UI组件是放置到一个专门的view容器中,这个View容器就是ViewGroup。

    2,ViewGroup的作用就是对添加进它的View组件进行布局。

    3,可惜,android.view.ViewGoup类是抽象类,不能直接使用它。

    ViewGroup类的实现

    对ViewGoup的实现的类有很多,它们有着各自的布局特点,比如LinearLayout类是把它包括的元素按照水平和竖直的方向排列。

    Android关于ViewGroup的解释还是比较清楚的,通过这个我们可以看出几点:

    1ViewGroup是一个容器,而这个容器是继承与View的。

    2ViewGroup是一个基类,并且是Layout和一些View组件的基类。

    1onLayout方法

    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

    }

    在我们继承ViewGroup时会在除了构造函数之外提供这个方法,我们可以看到,在ViewGroup的源代码中方法是这样定义的,也就是父类没有提供方法的内容,需要我们自己实现。

    当View要为所有子对象分配大小和位置时,调用此方法

    2、addView方法

    public void addView(View child) {
            addView(child, -1);
    }

    这个方法是用来想View容器中添加组件用的。我们可以使用这个方法想这个ViewGroup中添加组件。

    3、getChildAt方法

    复制代码
    public View getChildAt(int index) {
            try {
                return mChildren[index];
            } catch (IndexOutOfBoundsException ex) {
                return ;
            }
    }
    复制代码

     这个方法用来返回指定位置的View。

     注意:ViewGroup中的View是从0开始计数的。

    简单测试:

    创建一个MyViewGroup继承ViewGroup


    1. public class MyViewGroup extends ViewGroup {  
    2.   
    3.     public MyViewGroup(Context context) {  
    4.         super(context);  
    5.         myAddView();  
    6.     }  
    7.   
    8.     @Override  
    9.     protected void onLayout(boolean arg0, int arg1, int arg2, int arg3, int arg4) {  
    10.          View v = getChildAt(0);  
    11.          v.layout(arg1,arg2,arg3,arg4);  
    12.     }  
    13.   
    14.     @Override  
    15.     public void addView(View child) {  
    16.         super.addView(child);  
    17.     }  
    18.   
    19.      public void myAddView(){  
    20.             ImageView mIcon = new ImageView(this.getContext());  
    21.             mIcon.setImageResource(R.drawable.guid_image);  
    22.             addView(mIcon);  
    23.         }  
    24. }  
    public class MyViewGroup extends ViewGroup {
    
    
    public MyViewGroup(Context context) {
        super(context);
        myAddView();
    }
    
    @Override
    protected void onLayout(boolean arg0, int arg1, int arg2, int arg3, int arg4) {
         View v = getChildAt(0);
         v.layout(arg1,arg2,arg3,arg4);
    }
    
    @Override
    public void addView(View child) {
        super.addView(child);
    }
    
     public void myAddView(){
            ImageView mIcon = new ImageView(this.getContext());
            mIcon.setImageResource(R.drawable.guid_image);
            addView(mIcon);
        }
    

    }

    mainActivity中只要:


    1. @Override  
    2. protected void onCreate(Bundle savedInstanceState) {  
    3.     super.onCreate(savedInstanceState);  
    4.     this.setContentView(new MyViewGroup(this));  
    5. }  
     @Override 
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    this.setContentView(new MyViewGroup(this));
    }




    展开全文
  • Android 手把手教您自定义ViewGroup(一)

    万次阅读 多人点赞 2016-08-10 19:42:06
    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38339817 , 本文出自:【张鸿洋的博客】...说白了,就是教大家如何自定义ViewGroup,如果你对自定义ViewGroup还不是很了解,或者正想学习如何自

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38339817 , 本文出自:【张鸿洋的博客】

    最近由于工作的变动,导致的博客的更新计划有点被打乱,希望可以尽快脉动回来~

    今天给大家带来一篇自定义ViewGroup的教程,说白了,就是教大家如何自定义ViewGroup,如果你对自定义ViewGroup还不是很了解,或者正想学习如何自定义,那么你可以好好看看这篇博客。

    1、概述

    在写代码之前,我必须得问几个问题:

    1、ViewGroup的职责是啥?

    ViewGroup相当于一个放置View的容器,并且我们在写布局xml的时候,会告诉容器(凡是以layout为开头的属性,都是为用于告诉容器的),我们的宽度(layout_width)、高度(layout_height)、对齐方式(layout_gravity)等;当然还有margin等;于是乎,ViewGroup的职能为:给childView计算出建议的宽和高和测量模式 ;决定childView的位置;为什么只是建议的宽和高,而不是直接确定呢,别忘了childView宽和高可以设置为wrap_content,这样只有childView才能计算出自己的宽和高。

    2、View的职责是啥?

    View的职责,根据测量模式和ViewGroup给出的建议的宽和高,计算出自己的宽和高;同时还有个更重要的职责是:在ViewGroup为其指定的区域内绘制自己的形态。

    3、ViewGroup和LayoutParams之间的关系?

    大家可以回忆一下,当在LinearLayout中写childView的时候,可以写layout_gravity,layout_weight属性;在RelativeLayout中的childView有layout_centerInParent属性,却没有layout_gravity,layout_weight,这是为什么呢?这是因为每个ViewGroup需要指定一个LayoutParams,用于确定支持childView支持哪些属性,比如LinearLayout指定LinearLayout.LayoutParams等。如果大家去看LinearLayout的源码,会发现其内部定义了LinearLayout.LayoutParams,在此类中,你可以发现weight和gravity的身影。

    2、View的3种测量模式

    上面提到了ViewGroup会为childView指定测量模式,下面简单介绍下三种测量模式:

    EXACTLY:表示设置了精确的值,一般当childView设置其宽、高为精确值、match_parent时,ViewGroup会将其设置为EXACTLY;

    AT_MOST:表示子布局被限制在一个最大值内,一般当childView设置其宽、高为wrap_content时,ViewGroup会将其设置为AT_MOST;

    UNSPECIFIED:表示子布局想要多大就多大,一般出现在AadapterView的item的heightMode中、ScrollView的childView的heightMode中;此种模式比较少见。

    注:上面的每一行都有一个一般,意思上述不是绝对的,对于childView的mode的设置还会和ViewGroup的测量mode有一定的关系;当然了,这是第一篇自定义ViewGroup,而且绝大部分情况都是上面的规则,所以为了通俗易懂,暂不深入讨论其他内容。

    3、从API角度进行浅析

    上面叙述了ViewGroup和View的职责,下面从API角度进行浅析。

    View的根据ViewGroup传人的测量值和模式,对自己宽高进行确定(onMeasure中完成),然后在onDraw中完成对自己的绘制。

    ViewGroup需要给View传入view的测量值和模式(onMeasure中完成),而且对于此ViewGroup的父布局,自己也需要在onMeasure中完成对自己宽和高的确定。此外,需要在onLayout中完成对其childView的位置的指定。

    4、完整的例子

    需求:我们定义一个ViewGroup,内部可以传入0到4个childView,分别依次显示在左上角,右上角,左下角,右下角。

    1、决定该ViewGroup的LayoutParams

    对于我们这个例子,我们只需要ViewGroup能够支持margin即可,那么我们直接使用系统的MarginLayoutParams

    @Override
    	public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs)
    	{
    		return new MarginLayoutParams(getContext(), attrs);
    	}

    重写父类的该方法,返回MarginLayoutParams的实例,这样就为我们的ViewGroup指定了其LayoutParams为MarginLayoutParams。

    2、onMeasure

    在onMeasure中计算childView的测量值以及模式,以及设置自己的宽和高:

    /**
    	 * 计算所有ChildView的宽度和高度 然后根据ChildView的计算结果,设置自己的宽和高
    	 */
    	@Override
    	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    	{
    		/**
    		 * 获得此ViewGroup上级容器为其推荐的宽和高,以及计算模式
    		 */
    		int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    		int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    		int sizeWidth = MeasureSpec.getSize(widthMeasureSpec);
    		int sizeHeight = MeasureSpec.getSize(heightMeasureSpec);
    
    
    		// 计算出所有的childView的宽和高
    		measureChildren(widthMeasureSpec, heightMeasureSpec);
    		/**
    		 * 记录如果是wrap_content是设置的宽和高
    		 */
    		int width = 0;
    		int height = 0;
    
    		int cCount = getChildCount();
    
    		int cWidth = 0;
    		int cHeight = 0;
    		MarginLayoutParams cParams = null;
    
    		// 用于计算左边两个childView的高度
    		int lHeight = 0;
    		// 用于计算右边两个childView的高度,最终高度取二者之间大值
    		int rHeight = 0;
    
    		// 用于计算上边两个childView的宽度
    		int tWidth = 0;
    		// 用于计算下面两个childiew的宽度,最终宽度取二者之间大值
    		int bWidth = 0;
    
    		/**
    		 * 根据childView计算的出的宽和高,以及设置的margin计算容器的宽和高,主要用于容器是warp_content时
    		 */
    		for (int i = 0; i < cCount; i++)
    		{
    			View childView = getChildAt(i);
    			cWidth = childView.getMeasuredWidth();
    			cHeight = childView.getMeasuredHeight();
    			cParams = (MarginLayoutParams) childView.getLayoutParams();
    
    			// 上面两个childView
    			if (i == 0 || i == 1)
    			{
    				tWidth += cWidth + cParams.leftMargin + cParams.rightMargin;
    			}
    
    			if (i == 2 || i == 3)
    			{
    				bWidth += cWidth + cParams.leftMargin + cParams.rightMargin;
    			}
    
    			if (i == 0 || i == 2)
    			{
    				lHeight += cHeight + cParams.topMargin + cParams.bottomMargin;
    			}
    
    			if (i == 1 || i == 3)
    			{
    				rHeight += cHeight + cParams.topMargin + cParams.bottomMargin;
    			}
    
    		}
    		
    		width = Math.max(tWidth, bWidth);
    		height = Math.max(lHeight, rHeight);
    
    		/**
    		 * 如果是wrap_content设置为我们计算的值
    		 * 否则:直接设置为父容器计算的值
    		 */
    		setMeasuredDimension((widthMode == MeasureSpec.EXACTLY) ? sizeWidth
    				: width, (heightMode == MeasureSpec.EXACTLY) ? sizeHeight
    				: height);
    	}

    10-14行,获取该ViewGroup父容器为其设置的计算模式和尺寸,大多情况下,只要不是wrap_content,父容器都能正确的计算其尺寸。所以我们自己需要计算如果设置为wrap_content时的宽和高,如何计算呢?那就是通过其childView的宽和高来进行计算。

    17行,通过ViewGroup的measureChildren方法为其所有的孩子设置宽和高,此行执行完成后,childView的宽和高都已经正确的计算过了

    43-71行,根据childView的宽和高,以及margin,计算ViewGroup在wrap_content时的宽和高。

    80-82行,如果宽高属性值为wrap_content,则设置为43-71行中计算的值,否则为其父容器传入的宽和高。

    3、onLayout对其所有childView进行定位(设置childView的绘制区域)

    // abstract method in viewgroup
    	@Override
    	protected void onLayout(boolean changed, int l, int t, int r, int b)
    	{
    		int cCount = getChildCount();
    		int cWidth = 0;
    		int cHeight = 0;
    		MarginLayoutParams cParams = null;
    		/**
    		 * 遍历所有childView根据其宽和高,以及margin进行布局
    		 */
    		for (int i = 0; i < cCount; i++)
    		{
    			View childView = getChildAt(i);
    			cWidth = childView.getMeasuredWidth();
    			cHeight = childView.getMeasuredHeight();
    			cParams = (MarginLayoutParams) childView.getLayoutParams();
    
    			int cl = 0, ct = 0, cr = 0, cb = 0;
    
    			switch (i)
    			{
    			case 0:
    				cl = cParams.leftMargin;
    				ct = cParams.topMargin;
    				break;
    			case 1:
    				cl = getWidth() - cWidth - cParams.leftMargin
    						- cParams.rightMargin;
    				ct = cParams.topMargin;
    
    				break;
    			case 2:
    				cl = cParams.leftMargin;
    				ct = getHeight() - cHeight - cParams.bottomMargin;
    				break;
    			case 3:
    				cl = getWidth() - cWidth - cParams.leftMargin
    						- cParams.rightMargin;
    				ct = getHeight() - cHeight - cParams.bottomMargin;
    				break;
    
    			}
    			cr = cl + cWidth;
    			cb = cHeight + ct;
    			childView.layout(cl, ct, cr, cb);
    		}
    
    	}

    代码比较容易懂:遍历所有的childView,根据childView的宽和高以及margin,然后分别将0,1,2,3位置的childView依次设置到左上、右上、左下、右下的位置。

    如果是第一个View(index=0) :则childView.layout(cl, ct, cr, cb); cl为childView的leftMargin , ct 为topMargin , cr 为cl+ cWidth , cb为 ct + cHeight

    如果是第二个View(index=1) :则childView.layout(cl, ct, cr, cb); 

    cl为getWidth() - cWidth - cParams.leftMargin- cParams.rightMargin;

    ct 为topMargin , cr 为cl+ cWidth , cb为 ct + cHeight

    剩下两个类似~

    这样就完成了,我们的ViewGroup代码的编写,下面我们进行测试,分别设置宽高为固定值,wrap_content,match_parent

    5、测试结果

    布局1:

    <com.example.zhy_custom_viewgroup.CustomImgContainer xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:background="#AA333333" >
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#FF4444"
            android:gravity="center"
            android:text="0"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#00ff00"
            android:gravity="center"
            android:text="1"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#ff0000"
            android:gravity="center"
            android:text="2"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#0000ff"
            android:gravity="center"
            android:text="3"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
    </com.example.zhy_custom_viewgroup.CustomImgContainer>

    ViewGroup宽和高设置为固定值

    效果图:



    布局2:

    <com.example.zhy_custom_viewgroup.CustomImgContainer xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="#AA333333" >
    
        <TextView
            android:layout_width="150dp"
            android:layout_height="150dp"
            android:background="#E5ED05"
            android:gravity="center"
            android:text="0"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#00ff00"
            android:gravity="center"
            android:text="1"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#ff0000"
            android:gravity="center"
            android:text="2"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#0000ff"
            android:gravity="center"
            android:text="3"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
    </com.example.zhy_custom_viewgroup.CustomImgContainer>
    ViewGroup的宽和高设置为wrap_content
    效果图:



    布局3:

    <com.example.zhy_custom_viewgroup.CustomImgContainer xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#AA333333" >
    
        <TextView
            android:layout_width="150dp"
            android:layout_height="150dp"
            android:background="#E5ED05"
            android:gravity="center"
            android:text="0"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#00ff00"
            android:gravity="center"
            android:text="1"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="50dp"
            android:layout_height="50dp"
            android:background="#ff0000"
            android:gravity="center"
            android:text="2"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
        <TextView
            android:layout_width="150dp"
            android:layout_height="150dp"
            android:background="#0000ff"
            android:gravity="center"
            android:text="3"
            android:textColor="#FFFFFF"
            android:textSize="22sp"
            android:textStyle="bold" />
    
    </com.example.zhy_custom_viewgroup.CustomImgContainer>

    ViewGroup的宽和高设置为match_parent



    可以看到无论ViewGroup的宽和高的值如何定义,我们的需求都实现了预期的效果~~

    好了,通过这篇教程,希望大家已经能够初步掌握自定义ViewGroup的步骤,大家可以尝试自定义ViewGroup去实现LinearLayout的效果~~

    最后说明下,此为第一篇ViewGroup的教程,以后还会进一步的探讨如何更好的自定义ViewGroup~~~


    如果你觉得这篇文章对你有用,那么赞一个或者留个言吧~




    源码点击下载




    展开全文
  • 概述: Android系统中的所有UI类都是建立在View和ViewGroup这两个类的基础上的。所有View的子类成为”Widget”,所有ViewGroup的子类成为”Layout”。View和ViewGroup之间采用了组合设计模式,可以使得“部分-整体”...
    1. 概述:

      Android系统中的所有UI类都是建立在View和ViewGroup这两个类的基础上的。所有View的子类成为”Widget”,所有ViewGroup的子类成为”Layout”。View和ViewGroup之间采用了组合设计模式,可以使得“部分-整体”同等对待。ViewGroup作为布局容器类的最上层,布局容器里面又可以有View和ViewGroup。

      当我们运行程序的时候,有一个setContentView()方法,Activity其实不是显示视图(直观上感觉是它),实际上Activity调用了PhoneWindow的setContentView()方法,然后加载视图,将视图放到这个Window上,而Activity其实构造的时候初始化的是Window(PhoneWindow),Activity其实是个控制单元,即可视的人机交互界面。

    打个比方如下:

    Activity是一个工人,它来控制Window;Window是一面显示屏,用来显示信息;View就是要显示在显示屏上的信息,这些View都是层层重叠在一起(通过infalte()和addView())放到Window显示屏上的。而LayoutInfalter就是用来生成View的一个工具,XML布局文件就是用来生成View的原料。

    Activity、Window、View之间的关系:

    Activity是Window和View之间的桥梁,将View的内容信息显示在Window窗口上面。

    2.view和viewgroup

    一般来说,开发Android应用程序的UI界面都不会直接实用View和ViewGroup,而是使用这两大基类的派生类。

    View派生出的直接子类有:
    AnalogClock,ImageView,KeyboardView,ProgressBar,SurfaceView,TextView,ViewGroup,ViewStub
    
    View派生出的间接子类有:
     AbsListView,AbsSeekBar, AbsSpinner, AbsoluteLayout, AdapterView<T extends Adapter>,AdapterViewAnimator, AdapterViewFlipper, AppWidgetHostView, AutoCompleteTextView,Button,CalendarView, CheckBox, CheckedTextView, Chronometer, CompoundButton,
    
    ViewGroup派生出的直接子类有:
    AbsoluteLayout,AdapterView<T extends Adapter>,FragmentBreadCrumbs,FrameLayout,LinearLayout,RelativeLayout,SlidingDrawer
    
    ViewGroup派生出的间接子类有:
    
        AbsListView,AbsSpinner, AdapterViewAnimator, AdapterViewFlipper, AppWidgetHostView, CalendarView, DatePicker, DialerFilter, ExpandableListView, Gallery, GestureOverlayView,GridView,HorizontalScrollView, ImageSwitcher,ListView,

    3.分析

    Android View和ViewGroup从组成架构上看,似乎ViewGroup在View之上,View需要继承ViewGroup,但实际上不是这样的。 View是基类,ViewGroup是它的子类。这就证明了一点,View代表了用户界面组件的一块可绘制的空间块。每一个View在屏幕上占据一个长方 形区域。在这个区域内,这个VIEW对象负责图形绘制和事件处理。View是小控件widgets和ViewGroup的父类。ViewGroup又是 Layout的基类。
    这里写图片描述

    通过这些函数可以了解一个屏幕的宽、高及分辨率还有是横屏还坚屏等一些基本情况,透过这些函数,我们开发应用时可以方便的得到当前安装我这个应用的屏幕的 大小,以便调整应用使用户得到更好的用户体验。接下来我们看其它三者之间的关系,我想大家虽然看了前面的View的介绍和SDK中关系UI的基本介绍之后 还是对Android图形窗口十分困惑,看API也是,有WindowMangaer接口和Window类,但是在说明文档中,并未提到如何用这些。但实 际上这里面要去看到Android核心,Android核心底层GDI是SKIA,同chrome是一样的GDI,但是GUI是不一样的。这里面 Android实现的是C/S模式。如下图所示

    这里写图片描述

     从上图,我们可以理出大致的显示过程如下:
    

    【1】ActivityManagerService创建Activity线程,激活一个activity

    【2】系统调用Instrumentation.newActivity创建一个activity

    【3】Activity创建后,attach到一个新创建的phonewindow中。这样Activity获取一个唯一的WindowManager服务的实例

    【4】Activity创建过程中使用setcontentView设置用用户UI,这些VIEW被加入到PhoneWindow的ContentParent中。

    【5】Activity线程继续执行,当执行到Activity.makeVisible是将根view DecoView加入到WindowManger中,WindowManger实全会为每个DecoView创建对应的ViewRoot

    【6】每个ViewRoot拥有一个Surface,每个Surface将会调用底层库创建图形绘制的内存空间。这个底层库就是SurfaceFlinger。SurfaceFlinger同时也负责将个View绘制的图形合到一块(按照Z轴)显示到用户屏幕。

    【7】如果用户直接在Canvas上绘制,实际上它直接操作Surface。但对每个View的变更,它是要通知到ViewRoot,然后 ViewRoot获取Canvas。如果绘制完成,surfaceFlinger得到

    通知,合并Surface成一个Surface到设备屏幕。
    从上面的图形输出过程分析,我们可以知道真正显示图形的实际上跟Activity没有关系,完全由WindowManager来决定。 WindowManager是一个系统服务,因此可以直接调用这个服务来创建界面,并且更绝的是Dialog、Menu也是有WindowManager 来管理的。另外一个我们也可以看到,最底层都是Surface来,因此,常见开发游戏的人都推荐你使用SurfaceView来创建界面。

    最后,给大家介绍下View和ViewGroup最重要的几个方法——
    

    protected void onDraw(Canvas canvas):

    View类中用于重绘的方法,这个方法是所有View、ViewGroup及其派生类都具有的方法,也是Android UI绘制最重要的方法。开发者可重载该方法,并在重载的方法内部基于参数canvas绘制自己的各种图形、图像效果。

    protected void onLayout(boolean changed, int left, int top, int right, int bottom):

    View类中布局发生改变时会调用的方法,这个方法是所有View、ViewGroup及其派生类都具有的方法,重载该类可以在布局发生改变时作定制处理,这在实现一些特效时非常有用。

    protected void dispatchDraw(Canvas canvas):

    ViewGroup类及其派生类具有的方法,这个方法主要用于控制子View的绘制分发,重载该方法可改变子View的绘制,进而实现一些复杂的视效,典型的例子可参见Launcher模块Workspace的dispatchDraw重载。

    protected boolean drawChild(Canvas canvas, View child, long drawingTime)):

    ViewGroup类及其派生类具有的方法,这个方法直接控制绘制某局具体的子view,重载该方法可控制具体某个具体子View。

    4.寄言:

    View、ViewGroup是Android UI体系至关重要的两大基类,本文仅对一些最基本的概念、原理和API进行了介绍,大家要全面掌握还需要阅读SDK中对这两个类的介绍并熟悉其API 并在应用开发中逐渐的加深理解和掌握其用法。毕竟这些是自定义view最基础的知识了。

    展开全文
  • Android中View和ViewGroup介绍

    万次阅读 多人点赞 2013-08-08 17:17:56
    1. 概念 Android中的View与我们以前理解的...ViewGroup是View的子类,所以它也具有View的特性,但它主要用来充当View的容器,将其中的View视作自己的孩子,对它的子View进行管理,当然它的孩子也可以是ViewGroup类型。

    1. 概念
    Android中的View与我们以前理解的“视图”不同。在Android中,View比视图具有更广的含义,它包含了用户交互和显示,更像Windows操作系统中的window。

    ViewGroup是View的子类,所以它也具有View的特性,但它主要用来充当View的容器,将其中的View视作自己的孩子,对它的子View进行管理,当然它的孩子也可以是ViewGroup类型。

    ViewGroup(树根)和它的孩子们(View和ViewGroup)以树形结构形成了一个层次结构,View类有接受和处理消息的功能,android系统所产生的消息会在这些ViewGroup和 View之间传递。

    2.          Android的窗口系统
    Android的窗口系统是Client/Server模式的,我在这里只讲窗口系统的客户端(图1)。     我们所提到的概念:View,ViewGroup,DecorView,ViewRoot都是存在于窗口系统的Client端。

    Android中的Window是表示Top Level等顶级窗口的概念。DecorView是Window的Top-Level View,这个View可以称之为主View,DecorView会缺省的attach到Activity的主窗口中。

    ViewRoot建立了主View(DecorView)与窗口系统Server端的通讯桥梁, ViewRoot是 Handler的子类,即它其实是个Handler,它接受窗口系统服务器端的消息并将消息投递到窗口系统的客户端(图1),然后消息就从客户端的主View往其下面的子View传递,直到消息被完全处理掉为止。

     

    图1 窗口系统的客户端

      

      DecorView实际上是一个ViewGroup。在依存关系上来讲,对单个主窗口来讲,DecorView是Top-Level View。View并不是关注的重点,重要的是我们需要知道消息分发路径是建立在什么关系上的。View的成员变量mParent用来管理View上级关系的。而ViewGroup顾名思义就是一组View的管理,于是在ViewGroup构建了焦点管理和子View节点数组。这样通过View的mParent和ViewGroup的mChildren构建了Android中View直接的关系网。

     

     

     

     

    3.          View的介绍
    (1)     事件和绘制

    绘制流程:

    绘制按照视图树的顺序执行。视图绘制时会先绘制子控件。如果视图的背景可见,视图会在调用onDraw函数之前绘制背景。强制重绘,可以使用invalidate()。

     

    事件的基本流程如下:
             1、事件分配给相应视图,视图处理它,并通知相关监听器。
             2、操作过程中如果发生视图的尺寸变化,则该视图用调用requestLayout()方法,向父控件请求再次布局。
             3、操作过程中如果发生视图的外观变化,则该视图用调用invalidate()方法,请求重绘。
             4、如果requestLayout()或invalidate()有一个被调用,框架会对视图树进行相关的测量、布局和绘制。
            注意,视图树是单线程操作,直接调用其它视图的方法必须要在UI线程里。跨线程的操作必须使用句柄Handler。

     

    焦点处理:
            框架处理焦点的转移,来响应用户输入。isFocusable()函数表示视图是否能接受焦点。setFocusable(boolean)函数可以改变视图能否接受焦点。触摸屏模式(Touch Mode)的相关函数是isFocusableInTouchMode()和setFocusableInTouchMode(boolean)。
            焦点转移按照就近算法。按哪个方向就近可以在XML布局文件中配置。
             nextFocusDown
             nextFocusLeft
             nextFocusRight
             nextFocusUp
            视图请求焦点可以使用requestFocus()。

     

    (2) 成员介绍

    protected ViewParent mParent;

    mParent用于记录它的父亲,就是我们前面提到的ViewGroup。

     

    protected OnClickListener mOnClickListener;

    mOnClickListener是click事件的回调接口.

    大家经常使用的setOnClickListener(OnClickListener listener):

    public void setOnClickListener(OnClickListener I) {

            if (!isClickable()) {

                setClickable(true);

            }

            mOnClickListener =I;

    }

    可以看出,mOnClickListener其实就是保存我们在应用程序中定义的OnClickListener接口的。

     

    public void draw(Canvas canvas)

    这个函数用于渲染View和它的孩子,我们不应该在子类对它进行override。

     

    protected void onDraw(Canvas canvas)

    我们一般override此函数来实现自己的绘制操作。

     

    IWindowSession getWindowSession() {

            return mAttachInfo != null ? mAttachInfo.mSession : null;

    }

    函数getWindowSession()用户得到窗口系统Client端和服务器端通讯的接口IWindowSession。这是一个AIDL接口,android系统中的跨进程通讯就是用AIDL接口实现的。

     

    public final void layout(int l, int t, int r, int b)

    此函数用于确定View和其子View的尺寸和位置,它的调用发生在onMeasure之后。

     

    protected void onLayout(boolean changed, int left, int top, int right, int bottom)

    此函数在layout调用完成后执行,View的子类一般override此函数,并在函数中对其每个孩子调用layout方法。

     

     

    public View getRootView()

    此函数用于得到View层次结构的top-level View,即上文中提到的DecorView。

     

    public final void measure(int widthMeasureSpec, int heightMeasureSpec)

    此函数用户找出View的大小,它的参数widthMeasureSpec、heightMeasureSpec是其父亲传递给它的,这2个参数是View找出其大小时的限制条件,其实真正的精确大小确定是由onMeasure()完成的,onMeasure由measure函数调用。

     

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)

    此函数测量View并根据其内容来决定View的高和宽,它应该被子类override以实现大小的精确测量。在onMeasure中我们必须调用View.setMeasuredDimension(int, int)来保存测量得到的大小,高和宽分别被保存在View.mMeasuredHeight和View.mMeasureWidth中。

     

     

    public boolean onKeyUp(int keyCode, KeyEvent event)

    此函数会在键盘按键释放后被调用,但前提是View必须获得焦点。

     

    public boolean onTouchEvent(MotionEvent event)

    此函数用于响应触摸屏事件。

     

    public void invalidate()

    此函数将调用onDraw,强制重绘。

     

    public void requestLayout()

    当某些东西发生改变后,当前View层次结构无效了,调用此函数对View的层次结构进行重新布局。

     

    4.          ViewGroup介绍
     

    ViewGroup继承于View,它可以包含其他的View,就像一个View的容器,我们可以调用其成员函数addView()将View当作孩子放到ViewGroup中。

     

    我们经常使用的LinearLayout、relativeLayout等都是ViewGroup的子类,ViewGroup类中有一个内部类ViewGroup.LayoutParams,我们经常使用LayoutParams的子类来构造布局参数。

     

    我们也可以自定义自己的布局,以方便日后使用和维护,这时我们就需要继承ViewGroup类并在派生类中重写ViewGroup的一些方法,下面是一个简单的例子:

     

    public class MyViewGroup extends ViewGroup { 

        public MyViewGroup(Context context) { 

            super(context); 

            initChilren(context);   //向容器中添加孩子

        } 

        private void initChilren (Context context) { 

            Button aBtn = new Button(context);

            this.addView(aBtn); 

     

            Button bBtn = new Button(context);

            this.addView(bBtn); 

        }

     

        @Override

        protected void onLayout(boolean changed, int l, int t, int r, int b)

    //对容器的孩子进行布局。

    ………………

    ………………

        child.measure(r - l, b - t); 

        child.layout(0, 50, child.getMeasuredWidth(), child .getMeasuredHeight() + 50); 

    ………………

    ………………

         }

    }


    5. 不管是View还是ViewGroup,最重要一点他们的绘制原理如下:

    image

    从上图,我们可以理出大致的显示过程如下:
    【1】ActivityManagerService创建Activity线程,激活一个activity
    【2】系统调用Instrumentation.newActivity创建一个activity
    【3】Activity创建后,attach到一个新创建的phonewindow中。这样Activity获取一个唯一的WindowManager服务的实例
    【4】Activity创建过程中使用setcontentView设置用用户UI,这些VIEW被加入到PhoneWindow的ContentParent中。
    【5】Activity线程继续执行,当执行到Activity.makeVisible是将根view DecoView加入到WindowManger中,WindowManger实全会为每个DecoView创建对应的ViewRoot
    【6】每个ViewRoot拥有一个Surface,每个Surface将会调用底层库创建图形绘制的内存空间。这个底层库就是SurfaceFlinger。SurfaceFlinger同时也负责将个View绘制的图形合到一块(按照Z轴)显示到用户屏幕。
    【7】如果用户直接在Canvas上绘制,实际上它直接操作Surface。但对每个View的变更,它是要通知到ViewRoot,然后 ViewRoot获取Canvas。如果绘制完成,surfaceFlinger得到通知,合并Surface成一个Surface到设备屏幕。
    从上面的图形输出过程分析,我们可以知道真正显示图形的实际上跟Activity没有关系,完全由WindowManager来决定。 WindowManager是一个系统服务,因此可以直接调用这个服务来创建界面,并且更绝的是Dialog、Menu也是有WindowManager 来管理的。另外一个我们也可以看到,最底层都是Surface来,因此,常见开发游戏的人都推荐你使用SurfaceView来创建界面。

    详细绘制流程如下:

      整个View树的绘图流程是在ViewRoot.java类的performTraversals()函数展开的,该函数做的执行过程可简单概况为

     根之前状态,判断是否需要重新计算视图大小(measure)、是否重新需要安置视图的位置(layout)、以及是否需要重绘

     (draw),其框架过程如下:

                                                                                                       步骤其实为host.layout() 

               

     

     

          接下来温习一下整个View树的结构,对每个具体View对象的操作,其实就是个递归的实现。

     

                       

     


      流程一:      mesarue()过程


            主要作用:为整个View树计算实际的大小,即设置实际的高(对应属性:mMeasuredHeight)和宽(对应属性:

      mMeasureWidth),每个View的控件的实际宽高都是由父视图和本身视图决定的。

     

         具体的调用链如下

              ViewRoot根对象地属性mView(其类型一般为ViewGroup类型)调用measure()方法去计算View树的大小,回调

    View/ViewGroup对象的onMeasure()方法,该方法实现的功能如下:    

             1、设置本View视图的最终大小,该功能的实现通过调用setMeasuredDimension()方法去设置实际的高(对应属性:  

                    mMeasuredHeight)和宽(对应属性:mMeasureWidth)   ;

             2 、如果该View对象是个ViewGroup类型,需要重写该onMeasure()方法,对其子视图进行遍历的measure()过程。

                  

                   2.1  对每个子视图的measure()过程,是通过调用父类ViewGroup.java类里的measureChildWithMargins()方法去

              实现,该方法内部只是简单地调用了View对象的measure()方法。(由于measureChildWithMargins()方法只是一个过渡

              层更简单的做法是直接调用View对象的measure()方法)。

                  

         整个measure调用流程就是个树形的递归过程

     

         measure函数原型为 View.java 该函数不能被重载

          

    1. public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
    2.     //....  
    3.   
    4.     //回调onMeasure()方法    
    5.     onMeasure(widthMeasureSpec, heightMeasureSpec);  
    6.      
    7.     //more  
    8. }  

         为了大家更好的理解,采用“二B程序员”的方式利用伪代码描述该measure流程

     

    1. //回调View视图里的onMeasure过程  
    2. private void onMeasure(int height , int width){  
    3.  //设置该view的实际宽(mMeasuredWidth)高(mMeasuredHeight)  
    4.  //1、该方法必须在onMeasure调用,否者报异常。  
    5.  setMeasuredDimension(h , l) ;  
    6.    
    7.  //2、如果该View是ViewGroup类型,则对它的每个子View进行measure()过程  
    8.  int childCount = getChildCount() ;  
    9.    
    10.  for(int i=0 ;i<childCount ;i++){  
    11.   //2.1、获得每个子View对象引用  
    12.   View child = getChildAt(i) ;  
    13.     
    14.   //整个measure()过程就是个递归过程  
    15.   //该方法只是一个过滤器,最后会调用measure()过程 ;或者 measureChild(child , h, i)方法都  
    16.   measureChildWithMargins(child , h, i) ;   
    17.     
    18.   //其实,对于我们自己写的应用来说,最好的办法是去掉框架里的该方法,直接调用view.measure(),如下:  
    19.   //child.measure(h, l)  
    20.  }  
    21. }  
    22.   
    23. //该方法具体实现在ViewGroup.java里 。  
    24. protected  void measureChildWithMargins(View v, int height , int width){  
    25.  v.measure(h,l)     
    26. }  

    流程二、 layout布局过程:

     

         主要作用 :为将整个根据子视图的大小以及布局参数将View树放到合适的位置上。

     

         具体的调用链如下:

           host.layout()开始View树的布局,继而回调给View/ViewGroup类中的layout()方法。具体流程如下

      

            1 、layout方法会设置该View视图位于父视图的坐标轴,即mLeft,mTop,mLeft,mBottom(调用setFrame()函数去实现)

      接下来回调onLayout()方法(如果该View是ViewGroup对象,需要实现该方法,对每个子视图进行布局) ;

           

           2、如果该View是个ViewGroup类型,需要遍历每个子视图chiildView,调用该子视图的layout()方法去设置它的坐标值。

     

              layout函数原型为 ,位于View.java

    1. /* final 标识符 , 不能被重载 , 参数为每个视图位于父视图的坐标轴 
    2.  * @param l Left position, relative to parent 
    3.  * @param t Top position, relative to parent 
    4.  * @param r Right position, relative to parent 
    5.  * @param b Bottom position, relative to parent 
    6.  */  
    7. public final void layout(int l, int t, int r, int b) {  
    8.     boolean changed = setFrame(l, t, r, b); //设置每个视图位于父视图的坐标轴  
    9.     if (changed || (mPrivateFlags & LAYOUT_REQUIRED) == LAYOUT_REQUIRED) {  
    10.         if (ViewDebug.TRACE_HIERARCHY) {  
    11.             ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_LAYOUT);  
    12.         }  
    13.   
    14.         onLayout(changed, l, t, r, b);//回调onLayout函数 ,设置每个子视图的布局  
    15.         mPrivateFlags &= ~LAYOUT_REQUIRED;  
    16.     }  
    17.     mPrivateFlags &= ~FORCE_LAYOUT;  
    18. }  


        同样地, 将上面layout调用流程,用伪代码描述如下: 

    1. // layout()过程  ViewRoot.java  
    2. // 发起layout()的"发号者"在ViewRoot.java里的performTraversals()方法, mView.layout()  
    3.   
    4. private void  performTraversals(){  
    5.    
    6.     //...  
    7.       
    8.     View mView  ;  
    9.        mView.layout(left,top,right,bottom) ;  
    10.       
    11.     //....  
    12. }  
    13.   
    14. //回调View视图里的onLayout过程 ,该方法只由ViewGroup类型实现  
    15. private void onLayout(int left , int top , right , bottom){  
    16.   
    17.  //如果该View不是ViewGroup类型  
    18.  //调用setFrame()方法设置该控件的在父视图上的坐标轴  
    19.    
    20.  setFrame(l ,t , r ,b) ;  
    21.    
    22.  //--------------------------  
    23.    
    24.  //如果该View是ViewGroup类型,则对它的每个子View进行layout()过程  
    25.  int childCount = getChildCount() ;  
    26.    
    27.  for(int i=0 ;i<childCount ;i++){  
    28.   //2.1、获得每个子View对象引用  
    29.   View child = getChildAt(i) ;  
    30.   //整个layout()过程就是个递归过程  
    31.   child.layout(l, t, r, b) ;  
    32.  }  
    33. }  



       流程三、 draw()绘图过程

         由ViewRoot对象的performTraversals()方法调用draw()方法发起绘制该View树,值得注意的是每次发起绘图时,并不

      会重新绘制每个View树的视图,而只会重新绘制那些“需要重绘”的视图,View类内部变量包含了一个标志位DRAWN,当该

    视图需要重绘时,就会为该View添加该标志位。

     

       调用流程 :

         mView.draw()开始绘制,draw()方法实现的功能如下:

              1 、绘制该View的背景

              2 、为显示渐变框做一些准备操作(见5,大多数情况下,不需要改渐变框)          

              3、调用onDraw()方法绘制视图本身   (每个View都需要重载该方法,ViewGroup不需要实现该方法)

              4、调用dispatchDraw ()方法绘制子视图(如果该View类型不为ViewGroup,即不包含子视图,不需要重载该方法)

    值得说明的是,ViewGroup类已经为我们重写了dispatchDraw ()的功能实现,应用程序一般不需要重写该方法,但可以重载父类

      函数实现具体的功能。

     

                4.1 dispatchDraw()方法内部会遍历每个子视图,调用drawChild()去重新回调每个子视图的draw()方法(注意,这个 

    地方“需要重绘”的视图才会调用draw()方法)。值得说明的是,ViewGroup类已经为我们重写了dispatchDraw()的功能

    实现,应用程序一般不需要重写该方法,但可以重载父类函数实现具体的功能。

        

         5、绘制滚动条

     

      于是,整个调用链就这样递归下去了。

        

         同样地,使用伪代码描述如下:

        

    1. // draw()过程     ViewRoot.java  
    2. // 发起draw()的"发号者"在ViewRoot.java里的performTraversals()方法, 该方法会继续调用draw()方法开始绘图  
    3. private void  draw(){  
    4.    
    5.     //...  
    6.  View mView  ;  
    7.     mView.draw(canvas) ;    
    8.       
    9.     //....  
    10. }  
    11.   
    12. //回调View视图里的onLayout过程 ,该方法只由ViewGroup类型实现  
    13. private void draw(Canvas canvas){  
    14.  //该方法会做如下事情  
    15.  //1 、绘制该View的背景  
    16.  //2、为绘制渐变框做一些准备操作  
    17.  //3、调用onDraw()方法绘制视图本身  
    18.  //4、调用dispatchDraw()方法绘制每个子视图,dispatchDraw()已经在Android框架中实现了,在ViewGroup方法中。  
    19.       // 应用程序程序一般不需要重写该方法,但可以捕获该方法的发生,做一些特别的事情。  
    20.  //5、绘制渐变框    
    21. }  
    22.   
    23. //ViewGroup.java中的dispatchDraw()方法,应用程序一般不需要重写该方法  
    24. @Override  
    25. protected void dispatchDraw(Canvas canvas) {  
    26.  //   
    27.  //其实现方法类似如下:  
    28.  int childCount = getChildCount() ;  
    29.    
    30.  for(int i=0 ;i<childCount ;i++){  
    31.   View child = getChildAt(i) ;  
    32.   //调用drawChild完成  
    33.   drawChild(child,canvas) ;  
    34.  }       
    35. }  
    36. //ViewGroup.java中的dispatchDraw()方法,应用程序一般不需要重写该方法  
    37. protected void drawChild(View child,Canvas canvas) {  
    38.  // ....  
    39.  //简单的回调View对象的draw()方法,递归就这么产生了。  
    40.  child.draw(canvas) ;  
    41.    
    42.  //.........  
    43. }  


        强调一点的就是,在这三个流程中,Google已经帮我们把draw()过程框架已经写好了,自定义的ViewGroup只需要实现

     measure()过程和layout()过程即可 。


         这三种情况,最终会直接或间接调用到三个函数,分别为invalidate(),requsetLaytout()以及requestFocus() ,接着

    这三个函数最终会调用到ViewRoot中的schedulTraversale()方法,该函数然后发起一个异步消息,消息处理中调用

    performTraverser()方法对整个View进行遍历。

     

     

        invalidate()方法 :

     

       说明:请求重绘View树,即draw()过程,假如视图发生大小没有变化就不会调用layout()过程,并且只绘制那些“需要重绘的”

    视图,即谁(View的话,只绘制该View ;ViewGroup,则绘制整个ViewGroup)请求invalidate()方法,就绘制该视图。

     

         一般引起invalidate()操作的函数如下:

                1、直接调用invalidate()方法,请求重新draw(),但只会绘制调用者本身。

                2、setSelection()方法 :请求重新draw(),但只会绘制调用者本身。

                3、setVisibility()方法 : 当View可视状态在INVISIBLE转换VISIBLE时,会间接调用invalidate()方法,

                         继而绘制该View。

                4 、setEnabled()方法 : 请求重新draw(),但不会重新绘制任何视图包括该调用者本身。

     

        requestLayout()方法 :会导致调用measure()过程 和 layout()过程 。

     

               说明:只是对View树重新布局layout过程包括measure()和layout()过程,不会调用draw()过程,但不会重新绘制

    任何视图包括该调用者本身。

     

        一般引起invalidate()操作的函数如下:

             1、setVisibility()方法:

                 当View的可视状态在INVISIBLE/ VISIBLE 转换为GONE状态时,会间接调用requestLayout() 和invalidate方法。

        同时,由于整个个View树大小发生了变化,会请求measure()过程以及draw()过程,同样地,只绘制需要“重新绘制”的视图。

     

        requestFocus()函数说明:

     

              说明:请求View树的draw()过程,但只绘制“需要重绘”的视图。





    展开全文
  • 基础篇——View和ViewGroup的区别

    万次阅读 多人点赞 2020-04-30 15:05:42
    写代码的四点: 1.明确需求。要做什么? 2.分析思路。要怎么做?(1,2,3……) 3.确定步骤。每一个思路要用到哪些语句、方法和对象。 4.代码实现。用具体的语言代码将思路实现出来。... 1.... 2.... 3.......
  • View与ViewGroup的关系

    千次阅读 2019-04-17 12:53:01
    Android的UI界面都是由View和ViewGroup及其派生类组合而成的。  其中,View是所有UI组件的基类,而 ViewGroup是容纳这些组件的容器,其本身也是从View派生出来的.  View对象是Android平台中用户界面体现的基础单位...
  • Android 自定义ViewGroup 实战篇 -> 实现FlowLayout

    万次阅读 多人点赞 2016-08-10 19:41:56
    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/38352503 ,本文出自【张鸿洋的博客】1、概述上一篇已经基本给大家介绍了如何自定义ViewGroup,如果你还不了解,请查看:Android 手把手教您自...
  • 3.1.1 View与ViewGroup浅析

    万次阅读 2016-05-22 12:43:50
    3.1.1 View与ViewGroup浅析标签: StudyNote 本文声明: 本文由Coder-pig编写,想了解其他内容,可见CoderPig’s Android Study Note——目录 尊重作者劳动成果,未经本人授权,禁止转载!违者必究! 目录源...
  • Android ViewGroup事件分发机制

    万次阅读 多人点赞 2016-08-10 19:38:56
    上一篇已经完整的解析了Android View的事件分发机制,今天给大家代码ViewGroup事件分发的源码解析~~凡是自定义ViewGroup实现各种滑动效果的,不可避免的会出现很多事件的冲突,对ViewGroup事件分发机制的了解,也...
  • 首先拿到最外层的ViewGroup然后通过它拿到它所有的child然后循环每个child判断是ViewGroup还是View,如果是ViewGroup就继续遍历(递归),不是VieGroup的话那就是View了,那就直接打印View的id即可。 看代码吧。 /...
  • 上一篇博客我们主要介绍的是view的事件分发,这一篇文章我们主要介绍一些viewgroup的事件分发。 源码分析 我们知道当一个点击事件发生后它的传递过程遵循如下的顺序:activity-&amp;amp;gt; window-...
  • ================================================================ 预留填坑 ================================================================ ...大体思路,自定义一个ViewGroup,重写onMeasure,onLayout方法,
  • 最近在把一个之前写的一个界面封装成一个viewGroup的过程中发现了一个问题,viewgroup里面的 内容始终没有显示出来,在百度了几个小时之后,发现了问题出在那里。 一开始我认为这个控件不需要支持内边距,所以没有...
  • 自定义ViewGroup学习 最简单的模式,显示一个TextView到自定义ViewGroup
  • android之自定义viewGroup仿scrollView详解

    千次阅读 2017-02-17 10:55:29
    相信学了安卓的朋友都知道自定义viewGroup离不开重写onmeasure()和onLayout(),开始讲解代码之前,先来看看与这两个方法相关知识:  一、onMeasure() :这是测量自身的宽高和子view的宽高方法,测量涉及的知识点除了...
  • View和ViewGroup关系

    千次阅读 2018-08-15 23:17:43
    Android里的图形界面都是由View和ViewGroup以及他们的子类构成的: View:所有可视化控件的父类,提供组件描绘和时间处理方法 ViewGroup: View类的子类,可以拥有子控件,可以看作是容器 Android UI中的控件都是...
  • 以前对于触摸事件的分发过程有过专门的研究,当时把郭林大神讲...但是,后来在项目实战中发现好多一想不到的问题,郭大神的博客完全没法解释,凸(艹皿艹 ),然后自己打开ide,看ViewGroup源码发现跟郭大神博客里...
  • 本篇文章讲的是Android 自定义ViewGroup之实现标签流式布局-FlowLayout,开发中我们会经常需要实现类似于热门标签等自动换行的流式布局的功能,网上也有很多这样的FlowLayout,但不影响我对其的学习。和往常一样,...
  • Android View 事件分发机制源码详解(ViewGroup篇)

    万次阅读 热门讨论 2016-09-08 17:58:39
    前言我们在学习View的时候...由于View事件分发机制是一个比较复杂的机制,因此笔者将写成两篇文章来详细讲述,分别是ViewGroup和View。因为我们平时所接触的View都不是单一的View,往往是由若干个ViewGroup组合而成,而
  • 此前讲了很多,终于可以讲到这一节了,本文的例子是一个自定义的ViewGroup,左右滑动切换不同的页面,类似一个特别简化的ViewPager,这篇文章会涉及到这个系列的很多文章的内容比如View的measure、layout和draw流程...
1 2 3 4 5 ... 20
收藏数 166,212
精华内容 66,484
关键字:

viewgroup