Android LinearLayout 자동 줄 바 꾸 기 효과 구현

우리 가 개발 하 는 과정 에서 고객 의 요 구 를 자주 만 날 수 있 지만 안 드 로 이 드 시스템 은 효 과 를 제공 하지 않 습 니 다.이때 우 리 는 스스로 이 를 실현 하거나 인터넷 에서 다른 사람의 자원 을 참고 하여 다른 사람 이 자신 보다 못 하 다 는 마음으로 안 드 로 이 드 에서 자동 으로 줄 을 바 꾸 는 LinearLayout 를 어떻게 실현 하 는 지 정리 할 수 있 습 니 다.
본 논문 에서 LinearLayout 는 사실 GroupView 에서 계승 한 것 이 라 고 말 했 습 니 다.여기 서 주로 두 가지 방법,onMeasure,onLayout 방법 을 다시 썼 습 니 다.다음은 제 가 소개 하 겠 습 니 다.(코드 에 AttributeSet 을 사 용 했 습 니 다.시간 문제 로 더 이상 소개 하지 않 습 니 다).
1. onMeasure 는 뭐 하 는 사람 이에 요?
ViewGroup 을 만 드 는 과정 에서 onMeasure 는 onLayout 이전에 있 었 기 때문에 먼저 onMeasure 를 소개 합 니 다.onMeasure 방법 은 하위 컨트롤 과 부모 컨트롤 이 화면 에서 차지 하 는 길이 와 크기 를 계산 하 는 것 입 니 다.onMeasure 는 두 개의 매개 변수 인 widthMeasureSpec 와 height MeasureSpec 를 전달 합 니 다.이 두 매개 변 수 는 컨트롤 이 얻 을 수 있 는 공간 과 이 공간 에 대한 메타 데 이 터 를 가리 킵 니 다.

int withMode = MeasureSpec.getMode(widthMeasureSpec);
int withSize = MeasureSpec.getSize(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);

Mode 는 UNSPECIFIED,EXACTLY,AT 세 가지 모드 가 있 습 니 다.MOST,AT 라면MOST,Size 는 가장 얻 을 수 있 는 공간 을 대표 합 니 다.EXACTLY 라면 Size 는 정확 한 사 이 즈 를 대표 합 니 다.UNSPECIFIED 라면 원 하 는 만큼 하 는 거 야.코드 테스트 를 통 해 알 수 있 듯 이 width 나 height 를 fill 로 설정 합 니 다.parent 에서 용기 가 레이아웃 할 때 하위 view 를 호출 하 는 measure 방법 으로 들 어 오 는 모드 는 EXACTLY 입 니 다.하위 view 가 남 은 용기 의 공간 을 차지 하기 때문에 크기 가 확 정 됩 니 다.wrap 로 설정 하면content 시 용기 가 들 어 가 는 것 은 AT 입 니 다.MOST 는 하위 뷰 의 크기 가 얼마나 되 는 지 를 나타 내 는데 이 뷰 는 이 상한 선 에 따라 자신의 사 이 즈 를 설정 합 니 다.하위 view 의 크기 가 정확 한 값 으로 설정 되 었 을 때 용기 가 들 어 오 는 것 은 EXACTLY 입 니 다.
2. onLayout 뭐 하 는 사람 이에 요?
onMesaure 에 비해 onLayout 는 쉽게 이해 할 수 있 습 니 다.그 역할 은 좌석 을 바 꾸 는 것 입 니 다.모든 하위 View 를 필요 에 따라 View.layot(int l,int t,int r,int b)방법 으로 위 치 를 지정 하 는 것 입 니 다.
3. 문 제 를 해결 하 다
onMeasure 와 onLayout 를 이해 하기 만 하면 이 편 이 실현 하고 자 하 는 기능 에 대해 더 이상 실현 하기 어렵 지 않 습 니 다.아래 에 코드 를 붙 이 고 코드 에서 설명 합 니 다.
WaroLinearLayout.java

public class WarpLinearLayout extends ViewGroup {
 
  private Type mType;
  private List<WarpLine> mWarpLineGroup;
 
  public WarpLinearLayout(Context context) {
    this(context, null);
  }
 
  public WarpLinearLayout(Context context, AttributeSet attrs) {
    this(context, attrs, R.style.WarpLinearLayoutDefault);
  }
 
  public WarpLinearLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    mType = new Type(context, attrs);
  }
 
  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int withMode = MeasureSpec.getMode(widthMeasureSpec);
    int withSize = MeasureSpec.getSize(widthMeasureSpec);
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
    int with = 0;
    int height = 0;
    int childCount = getChildCount();
    /**
     *    childView。getMeasre           ，    View     
     */
    measureChildren(widthMeasureSpec, heightMeasureSpec);
    /**
     *     
     */
    switch (withMode) {
      case MeasureSpec.EXACTLY:
        with = withSize;
        break;
      case MeasureSpec.AT_MOST:
        for (int i = 0; i < childCount; i++) {
          if (i != 0) {
            with += mType.horizontal_Space;
          }
          with += getChildAt(i).getMeasuredWidth();
        }
        with += getPaddingLeft() + getPaddingRight();
        with = with > withSize ? withSize : with;
        break;
      case MeasureSpec.UNSPECIFIED:
        for (int i = 0; i < childCount; i++) {
          if (i != 0) {
            with += mType.horizontal_Space;
          }
          with += getChildAt(i).getMeasuredWidth();
        }
        with += getPaddingLeft() + getPaddingRight();
        break;
      default:
        with = withSize;
        break;
 
    }
    /**
     *         ，         
     */
    WarpLine warpLine = new WarpLine();
    /**
     *             ，  onMeasure       
     */
    mWarpLineGroup = new ArrayList<WarpLine>();
    for (int i = 0; i < childCount; i++) {
      if (warpLine.lineWidth + getChildAt(i).getMeasuredWidth() + mType.horizontal_Space > with) {
        if (warpLine.lineView.size() == 0) {
          warpLine.addView(getChildAt(i));
          mWarpLineGroup.add(warpLine);
          warpLine = new WarpLine();
        } else {
          mWarpLineGroup.add(warpLine);
          warpLine = new WarpLine();
          warpLine.addView(getChildAt(i));
        }
      } else {
        warpLine.addView(getChildAt(i));
      }
    }
    /**
     *       
     */
    if (warpLine.lineView.size() > 0 && !mWarpLineGroup.contains(warpLine)) {
      mWarpLineGroup.add(warpLine);
    }
    /**
     *     
     */
    height = getPaddingTop() + getPaddingBottom();
    for (int i = 0; i < mWarpLineGroup.size(); i++) {
      if (i != 0) {
        height += mType.vertical_Space;
      }
      height += mWarpLineGroup.get(i).height;
    }
    switch (heightMode) {
      case MeasureSpec.EXACTLY:
        height = heightSize;
        break;
      case MeasureSpec.AT_MOST:
        height = height > heightSize ? heightSize : height;
        break;
      case MeasureSpec.UNSPECIFIED:
        break;
      default:
        break;
    }
    setMeasuredDimension(with, height);
  }
 
  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    t = getPaddingTop();
    for (int i = 0; i < mWarpLineGroup.size(); i++) {
      int left = getPaddingLeft();
      WarpLine warpLine = mWarpLineGroup.get(i);
      int lastWidth = getMeasuredWidth() - warpLine.lineWidth;
      for (int j = 0; j < warpLine.lineView.size(); j++) {
        View view = warpLine.lineView.get(j);
        if (isFull()) {//        
          view.layout(left, t, left + view.getMeasuredWidth() + lastWidth / warpLine.lineView.size(), t + view.getMeasuredHeight());
          left += view.getMeasuredWidth() + mType.horizontal_Space + lastWidth / warpLine.lineView.size();
        } else {
          switch (getGrivate()) {
            case 0://   
              view.layout(left + lastWidth, t, left + lastWidth + view.getMeasuredWidth(), t + view.getMeasuredHeight());
              break;
            case 2://    
              view.layout(left + lastWidth / 2, t, left + lastWidth / 2 + view.getMeasuredWidth(), t + view.getMeasuredHeight());
              break;
            default://   
              view.layout(left, t, left + view.getMeasuredWidth(), t + view.getMeasuredHeight());
              break;
          }
          left += view.getMeasuredWidth() + mType.horizontal_Space;
        }
      }
      t += warpLine.height + mType.vertical_Space;
    }
  }
 
  /**
   *        View
   */
  private final class WarpLine {
    private List<View> lineView = new ArrayList<View>();
    /**
     *             
     */
    private int lineWidth = getPaddingLeft() + getPaddingRight();
    /**
     *   View           
     */
    private int height = 0;
 
    private void addView(View view) {
      if (lineView.size() != 0) {
        lineWidth += mType.horizontal_Space;
      }
      height = height > view.getMeasuredHeight() ? height : view.getMeasuredHeight();
      lineWidth += view.getMeasuredWidth();
      lineView.add(view);
    }
  }
 
  /**
   *        
   */
  private final static class Type {
    /*
     *     right 0，left 1，center 2
    */
    private int grivate;
    /**
     *     ,  px
     */
    private float horizontal_Space;
    /**
     *     ,  px
     */
    private float vertical_Space;
    /**
     *       
     */
    private boolean isFull;
 
    Type(Context context, AttributeSet attrs) {
      if (attrs == null) {
        return;
      }
      TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.WarpLinearLayout);
      grivate = typedArray.getInt(R.styleable.WarpLinearLayout_grivate, grivate);
      horizontal_Space = typedArray.getDimension(R.styleable.WarpLinearLayout_horizontal_Space, horizontal_Space);
      vertical_Space = typedArray.getDimension(R.styleable.WarpLinearLayout_vertical_Space, vertical_Space);
      isFull = typedArray.getBoolean(R.styleable.WarpLinearLayout_isFull, isFull);
    }
  }
 
  public int getGrivate() {
    return mType.grivate;
  }
 
  public float getHorizontal_Space() {
    return mType.horizontal_Space;
  }
 
  public float getVertical_Space() {
    return mType.vertical_Space;
  }
 
  public boolean isFull() {
    return mType.isFull;
  }
 
  public void setGrivate(int grivate) {
    mType.grivate = grivate;
  }
 
  public void setHorizontal_Space(float horizontal_Space) {
    mType.horizontal_Space = horizontal_Space;
  }
 
  public void setVertical_Space(float vertical_Space) {
    mType.vertical_Space = vertical_Space;
  }
 
  public void setIsFull(boolean isFull) {
    mType.isFull = isFull;
  }
 
  /**
   *    View     
   */
  public final static class Gravite {
    public final static int RIGHT = 0;
    public final static int LEFT = 1;
    public final static int CENTER = 2;
  }
}

attrs.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <declare-styleable name="WarpLinearLayout">
    <attr name="grivate" format="enum"><!--     !-->
      <enum name="right" value="0"></enum>
      <enum name="left" value="1"></enum>
      <enum name="center" value="2"></enum>
    </attr>
    <attr name="horizontal_Space" format="dimension"></attr>
    <attr name="vertical_Space" format="dimension"></attr>
    <attr name="isFull" format="boolean"></attr>
  </declare-styleable>
</resources>

WarpLinearLayoutDefault

<style name="WarpLinearLayoutDefault">
    <item name="grivate">left</item>
    <item name="horizontal_Space">20dp</item>
    <item name="vertical_Space">20dp</item>
    <item name="isFull">false</item>
</style>

MainActivity.java

public class MainActivity extends Activity {
  private Button btn;
  private WarpLinearLayout warpLinearLayout;
 
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    btn = (Button) findViewById(R.id.btn);
    warpLinearLayout = (WarpLinearLayout) findViewById(R.id.warpLinearLayout);
    btn.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        int n = new Random().nextInt(10) + 5;
        StringBuffer stringBuffer = new StringBuffer();
        Random random = new Random();
        Log.i("WarpLinearLayout","n="+n);
        for (int i = 0; i < n; i++) {
          stringBuffer.append((char)(65+random.nextInt(26)));
          Log.i("WarpLinearLayout", "StringBuffer=" + stringBuffer.toString());
        }
        TextView tv = new TextView(MainActivity.this);
        tv.setText(stringBuffer.toString()+"000");
        tv.setBackgroundResource(R.drawable.radius_backgroup_yellow);
        tv.setPadding(10,10,10,10);
        warpLinearLayout.addView(tv);
      }
    });
  }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:app="http://schemas.android.com/apk/res-auto"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:paddingBottom="@dimen/activity_vertical_margin"
  android:paddingLeft="@dimen/activity_horizontal_margin"
  android:paddingRight="@dimen/activity_horizontal_margin"
  android:paddingTop="@dimen/activity_vertical_margin"
  tools:context=".MainActivity">
 
  <Button
    android:id="@+id/btn"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:gravity="center"
    android:text="add"
    android:textSize="20dp" />
 
  <com.example.customview.viewgroup.WarpLinearLayout
    android:id="@+id/warpLinearLayout"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_below="@id/btn"
    android:background="#FF00FF00"
    android:padding="10dp"
    app:grivate="right"
    app:horizontal_Space="10dp"
    app:isFull="false"
    app:vertical_Space="10dp"></com.example.customview.viewgroup.WarpLinearLayout>
</RelativeLayout>

실행 효과 그림 은 다음 과 같 습 니 다:
 
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.