精华内容
下载资源
问答
  • void connect (int startID, int startSide, int endID, int endSide, int margin)
  • android 约束 布局In this tutorial, we’ll be implementing Constraint Layout ... 在本教程中,我们将在Android应用程序中实现约束布局动画。 约束布局动画 (Constraint Layout Animation) We can create beaut...

    android 约束 布局

    In this tutorial, we’ll be implementing Constraint Layout Animations in our Android Application.

    在本教程中,我们将在Android应用程序中实现约束布局动画。

    约束布局动画 (Constraint Layout Animation)

    We can create beautiful animations using ConstraintLayout quickly. To do so, we need to just change constraints!

    我们可以使用ConstraintLayout快速创建精美的动画。 为此,我们只需要更改约束即可!

    The most common and easy way to create Constraint Layout animations in by creating two different layouts.
    One is the start stage of the animation and the second is the end stage of the animation.

    通过创建两个不同的布局来创建约束布局动画的最常见,最简单的方法。
    第一个是动画的开始阶段,第二个是动画的结束阶段。

    Constraint Set is the class used to set constraints on the views of the Constraint Layout.

    约束集是用于在约束布局的视图上设置约束的类。

    约束集 (ConstraintSet)

    ConstraintSet is the class that is used to define constraints programmatically on the Constraint Layout.
    It can also retrieve the constraints present in the Constraint Layout by using clone() method.

    ConstraintSet是用于在Constraint Layout上以编程方式定义约束的类。
    它还可以使用clone()方法检索约束布局中存在的约束。

    clone() method is used to copy the constraints from the layout.

    clone()方法用于从布局复制约束。

    applyTo() is used to apply a constraint set onto the Constraint Layout.

    applyTo()用于将约束集应用于“约束布局”。

    A ConstraintSet is created just like any other Java object:

    与其他任何Java对象一样,创建ConstraintSet:

    ConstraintSet constraintSet = new ConstraintSet();

    To set constraints on the views programmatically, we need to use connect().

    要以编程方式在视图上设置约束,我们需要使用connect()

    connect() establishes connections between sibling views or a view and the parent view.

    connect()在兄弟视图或视图与父视图之间建立连接。

    To create a ConstraintLayout animation we need:

    要创建ConstraintLayout动画,我们需要:

    TransitionManager – To manage the transitions.
    beginDelayedTransition() – To start the transition from the first scene to second scene(first layout to the second layout).

    TransitionManager –管理过渡。
    beginDelayedTransition() –开始从第一个场景到第二个场景(从第一个布局到第二个布局)的过渡。

    applyTo() – To apply the final constraints on the second layout.

    applyTo() –在第二个布局上应用最终约束。


    The first layout should show constraints at the initial stage of the transition.
    第一个布局应在过渡的初始阶段显示约束。
    The second layout should show the constraints after the animation.
    第二个布局应在动画之后显示约束。

    This way the transition occurs!

    这样过渡就发生了!

    You need not set attributes and styles in the duplicated XML. It will be automatically captured from the first.

    您无需在重复的XML中设置属性和样式。 它会从第一个开始自动捕获。

    To use ConstraintSet, every view in the XML layout must have an ID.

    要使用ConstraintSet,XML布局中的每个视图都必须有一个ID。

    Enough talk! Let’s code.

    聊够了! 让我们编码。

    项目结构 (Project Structure)

    (Code)

    The code for the activity_main.xml layout is given below:

    下面给出了activity_main.xml布局的代码:

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout xmlns:android="https://schemas.android.com/apk/res/android"
        xmlns:app="https://schemas.android.com/apk/res-auto"
        xmlns:tools="https://schemas.android.com/tools"
        android:id="@+id/cc1"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    
        <ImageView
            android:id="@+id/backgroundImage"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:scaleType="centerCrop"
            android:src="@drawable/bg"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
        <EditText
            android:id="@+id/inPassword"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:hint="Password"
            android:paddingBottom="8dp"
            android:paddingEnd="24dp"
            android:paddingStart="24dp"
            android:paddingTop="8dp"
            android:textColor="#FFFF"
            android:background="@drawable/input_field"
            android:imeOptions="actionNext"
            android:inputType="textPassword"
            android:maxLines="1"
            android:layout_margin="16dp"
            android:textColorHint="#b3ffffff"
            android:textCursorDrawable="@null"
            app:layout_constraintBottom_toBottomOf="@+id/inUsername"
            app:layout_constraintLeft_toRightOf="@+id/backgroundImage" />
    
        <EditText
            android:id="@+id/inUsername"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="48dp"
            android:hint="Username"
            android:paddingBottom="8dp"
            android:paddingEnd="24dp"
            android:paddingStart="24dp"
            android:paddingTop="8dp"
            android:textColor="#FFFF"
            android:background="@drawable/input_field"
            android:imeOptions="actionNext"
            android:inputType="textEmailAddress"
            android:maxLines="1"
            android:layout_margin="16dp"
            android:textColorHint="#b3ffffff"
            android:textCursorDrawable="@null"
            app:layout_constraintRight_toLeftOf="@+id/backgroundImage"
            app:layout_constraintTop_toTopOf="parent" />
    
        <TextView
            android:id="@+id/tap"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginBottom="12dp"
            android:layout_marginEnd="8dp"
            android:layout_marginStart="8dp"
            android:text="Tap to animate"
            android:textColor="#ffffff"
            android:textSize="15sp"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent" />
    
        <Button
            android:id="@+id/btnLogin"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="#181818"
            android:gravity="center"
            android:text="LOGIN"
            android:textColor="#FFFF"
            android:textSize="18sp"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/backgroundImage" />
    
    </android.support.constraint.ConstraintLayout>

    The code for the drawable input_field.xml can be found in the source code/github repo present at the end of this tutorial.

    可绘制input_field.xml的代码可以在本教程结尾处提供的源代码/ github存储库中找到。

    The code for the final activity_main_animated.xml layout is :

    最终的activity_main_animated.xml布局的代码为:

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout xmlns:android="https://schemas.android.com/apk/res/android"
        xmlns:app="https://schemas.android.com/apk/res-auto"
        xmlns:tools="https://schemas.android.com/tools"
        android:id="@+id/cc2"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".MainActivity">
    
        <ImageView
            android:id="@+id/backgroundImage"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:scaleType="centerCrop"
            android:src="@drawable/bg"
            app:layout_constraintBottom_toTopOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
        <EditText
            android:id="@+id/inUsername"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="16dp"
            android:paddingBottom="8dp"
            android:paddingEnd="24dp"
            android:paddingStart="24dp"
            android:paddingTop="8dp"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
        <EditText
            android:id="@+id/inPassword"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="16dp"
            android:paddingBottom="8dp"
            android:paddingEnd="24dp"
            android:paddingStart="24dp"
            android:paddingTop="8dp"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/inUsername" />
    
        <TextView
            android:id="@+id/tap"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginBottom="8dp"
            android:layout_marginEnd="8dp"
            android:layout_marginStart="8dp"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent" />
    
        <Button
            android:id="@+id/btnLogin"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_margin="16dp"
            android:gravity="center"
            android:textSize="18sp"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toBottomOf="@+id/inPassword" />
    
    
    </android.support.constraint.ConstraintLayout>

    The code for the MainActivity.java is given below:

    MainActivity.java的代码如下:

    package com.journaldev.androidconstraintanimation;
    
    import android.support.constraint.ConstraintLayout;
    import android.support.constraint.ConstraintSet;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.transition.ChangeBounds;
    import android.transition.TransitionManager;
    import android.view.View;
    import android.view.animation.AnticipateInterpolator;
    import android.widget.ImageView;
    
    public class MainActivity extends AppCompatActivity {
    
    
        ImageView imageView;
        boolean show = false;
        ConstraintLayout cc1;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            cc1 = findViewById(R.id.cc1);
    
            imageView = findViewById(R.id.backgroundImage);
    
            imageView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    if (show)
                        revertAnimation();
                    else
                        showAnimation();
                }
            });
    
        }
    
        private void showAnimation() {
            show = true;
    
            ConstraintSet constraintSet = new ConstraintSet();
            constraintSet.clone(this, R.layout.activity_main_animation);
    
            ChangeBounds transition = new ChangeBounds();
            transition.setInterpolator(new AnticipateInterpolator(1.0f));
            transition.setDuration(1200);
    
            TransitionManager.beginDelayedTransition(cc1, transition);
            constraintSet.applyTo(cc1);
        }
    
        private void revertAnimation() {
            show = false;
    
            ConstraintSet constraintSet = new ConstraintSet();
            constraintSet.clone(this, R.layout.activity_main);
    
            ChangeBounds transition = new ChangeBounds();
            transition.setInterpolator(new AnticipateInterpolator(1.0f));
            transition.setDuration(1200);
    
            TransitionManager.beginDelayedTransition(cc1, transition);
            constraintSet.applyTo(cc1);
    
        }
    
    }

    Inside the TransitionManager we’ve set an interpolator class which has a predefined behaviour.

    在TransitionManager内,我们设置了一个具有预定义行为的插补器类。

    The output of the above application in action is given below:

    上面应用程序的输出如下:

    This brings an end to this tutorial. You can download the project from the link below:

    本教程到此结束。 您可以从下面的链接下载项目:

    翻译自: https://www.journaldev.com/23344/android-constraint-layout-animation

    android 约束 布局

    展开全文
  • android约束布局

    千次阅读 2018-09-03 20:09:48
    约束布局是谷歌在 使用: 为什么要使用约束布局: ConstraintLayout还有一个优点,它可以有效地解决布局嵌套过多的问题。 实现的布局效果类似于相对布局但比相对布局性能更高。 盗个别人对比的图: 从图中...

    约束布局是谷歌在

    使用:

    为什么要使用约束布局:

    1. ConstraintLayout还有一个优点,它可以有效地解决布局嵌套过多的问题。
    2. 实现的布局效果类似于相对布局但比相对布局性能更高。
      盗个别人对比的图:
      这里写图片描述
      从图中我们可以看出性能上约束布局比相对布局性能要好上40%左右,因此有这么好的布局方式为什么不用呢。

    使用方式:

    1.在项目中添加依赖:

    dependencies {
        compile 'com.android.support.constraint:constraint-layout:1.0.0-alpha1'
    }
    

    2.布局中使用:

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
    	<!--子控件-->
    
    </android.support.constraint.ConstraintLayout>
    

    实现子控件完全居中效果:

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/black">
    
        <!--垂直居中View-->
        <View
            android:id="@+id/view1"
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="#00ff00"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
        <!--水平居中的View-->
        <View
            android:id="@+id/view2"
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="#ff0000"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            />
        <!--完全居中的view-->
        <View
            android:id="@+id/view3"
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="@color/white"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    
        <!--右下角的View-->
        <View
            android:id="@+id/view4"
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="#0000ff"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            />
    
        <!--红色左侧部分居中及绿色上部分空白处居中-->
        <View
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="#00ffff"
            app:layout_constraintRight_toLeftOf="@id/view2"
            app:layout_constraintLeft_toLeftOf="parent"
    
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toTopOf="@id/view1"
            />
    </android.support.constraint.ConstraintLayout>
    

    效果图:
    这里写图片描述
    约束布局属性:

    layout_constraintTop_toTopOf       // 将所需视图的顶部与另一个视图的顶部对齐。 
    
    layout_constraintTop_toBottomOf    // 将所需视图的顶部与另一个视图的底部对齐。 
    
    layout_constraintBottom_toTopOf    // 将所需视图的底部与另一个视图的顶部对齐。 
    
    layout_constraintBottom_toBottomOf // 将所需视图的底部与另一个视图的底部对齐。 
    
    layout_constraintLeft_toTopOf      // 将所需视图的左侧与另一个视图的顶部对齐。 
    
    layout_constraintLeft_toBottomOf   // 将所需视图的左侧与另一个视图的底部对齐。 
    
    layout_constraintLeft_toLeftOf     // 将所需视图的左边与另一个视图的左边对齐。 
    
    layout_constraintLeft_toRightOf    // 将所需视图的左边与另一个视图的右边对齐。 
    
    layout_constraintRight_toTopOf     // 将所需视图的右对齐到另一个视图的顶部。
    
    layout_constraintRight_toBottomOf  // 将所需视图的右对齐到另一个的底部。
    
    layout_constraintRight_toLeftOf    // 将所需视图的右边与另一个视图的左边对齐。
    
    layout_constraintRight_toRightOf   // 将所需视图的右边与另一个视图的右边对齐。
    

    大概解释:

    • constraintRight/Left/Top/Bottom
      布局的哪一边添加约束

    • toRight/Left/Top/BottomOf
      约束到哪个View的右/左/上/下边

    注意:在添加外边距时如果没有在对应方向上添加约束则可能没有效果,比如一个View在parent左侧,且添加了marginLeft=20dp,则需要设置layout_constraintLeft_toLeftOf或者layout_constraintLeft_toRightOf才能使外边距生效。

    展开全文
  • android 约束 布局Creating a responsive UI in Native Android with nested view groups has always been a challenge for the native android apps developer community. 在本机Android中使用嵌套视图组创建响应式...

    android 约束 布局

    Creating a responsive UI in Native Android with nested view groups has always been a challenge for the native android apps developer community.

    在本机Android中使用嵌套视图组创建响应式UI一直是本机android应用程序开发人员社区面临的挑战。

    Constraint Layout is a big relief to the above problem. Google announced the layout in 2016's Google I/O. The Constraint layout is more or less similar to Relative Layout , but more flexible , better adapts to screen size changes and is easier to use with Android Studio’s Layout Editor. As per the official document “All the power of Constraint Layout is available directly from the Layout Editor's visual tools, because the layout API and the Layout Editor were specially built for each other. So you can build your layout with Constraint Layout entirely by drag-and-dropping instead of editing the XML.

    约束布局可以大大缓解上述问题。 Google宣布了2016年Google I / O的布局。 Constraint布局或多或少与Relative Layout相似,但是更灵活,更适应屏幕大小变化,并且更易于在Android Studio的Layout Editor中使用。 按照官方文档“ Constraint Layout的所有功能都可以直接从Layout Editor的可视化工具获得,因为layout API和Layout Editor是专门为彼此构建的。 因此,您可以通过拖放而不是编辑XML来完全使用约束布局来构建布局。

    什么是约束? (What is Constraint?)

    Constraints are the basic building blocks of this layout. It connects the anchor points of one widget with another widget or the parent. There are various kinds of constraint which are manipulated to create a responsive UI , which also adapts better with different screen size.

    约束是此布局的基本构建块。 它将一个窗口小部件的定位点与另一个窗口小部件或父窗口小部件连接起来。 有多种约束条件可以操纵以创建响应式UI,它也可以更好地适应不同的屏幕尺寸。

    各种约束: (Various Kinds of Constraints :)

    Relative positioning : These constraints allow you to position a given side of a widget relative to any other widget or to the parent view group either horizontally or vertically.

    相对定位 :通过这些约束,您可以相对于任何其他窗口小部件或父视图组水平或垂直放置窗口小部件的给定侧面。

    attribute used for Relative positioning : app:layout_constraint[source side]_to[target side]="[target id or parent]"

    用于相对定位的属性: app:layout_constraint[source side]_to[target side]="[target id or parent]"

    Centering positioning : This constraint is used to center a widget horizontally or vertically between two targets. The target can be another widget’s anchor point or parent’s anchor point. The two opposite constraint acts like two opposing forces keeping the widget centered between targets.

    居中定位 此约束用于将小部件水平或垂直居中在两个目标之间。 目标可以是另一个小部件的锚点或父级的锚点。 两个相反的约束就像两个相反的力一样,使小部件在目标之间居中。

    Image for post
    Center positioning of a widget (Image source : Google’s Android developer docs)
    小部件的中心定位(图片来源:Google的Android开发者文档)

    Bias : The center positioning of widgets may not be desired every time we try to create a layout. Sometimes the widget may need to favor a particular side more than the other. To achieve this use case we have been provided with Bias constraint. We can have horizontal and vertical bias of a widget.

    偏差:每次我们尝试创建布局时,都可能不需要小部件的中心定位。 有时,小部件可能需要比其他方面更偏向于特定方面。 为了实现这个用例,我们提供了Bias约束。 我们可以对小部件进行水平和垂直偏移。

    attribute used for Bias constraint :

    用于Bias约束的属性:

    app:layout_constraintHorizontal_bias="[float value ranging from 0 to 1]"

    app:layout_constraintHorizontal_bias="[float value ranging from 0 to 1]"

    app:layout_constraintVertical_bias="[float value ranging from 0 to 1]"

    app:layout_constraintVertical_bias="[float value ranging from 0 to 1]"

    The float value decides the percentage of Bias.

    浮点值决定偏差的百分比。

    For horizontal bias it decides what percentage the widget needs to be from the left side , for example : app:layout_constraintHorizontal_bias="0.3"

    对于水平偏差,它确定小部件需要从左侧占的百分比,例如: app:layout_constraintHorizontal_bias="0.3"

    The above attribute will keep the left side of the widget with a 30% bias instead of the default 50%. Below is the pictorial representation of the example.

    上面的属性将使小部件的左侧保持30%的偏差,而不是默认的50%。 下面是该示例的图形表示。

    Image for post
    Horizontal Bias ,Image source : Google’s Android developer docs
    水平偏差图片来源:Google的Android开发者文档

    For Vertical Bias , the float value decides , what percentage the widget needs to be from the top , for example ,

    对于Vertical Bias(垂直偏差),float值决定了小部件需要从顶部算起的百分比,例如

    app:layout_constraintVertical_bias="0.2"

    app:layout_constraintVertical_bias="0.2"

    The above attribute will keep the top of the widget with a 20% bias instead of the default 50%. Below is the pictorial representation of the example.

    上面的属性将使窗口小部件的顶部保持20%的偏差,而不是默认的50%。 下面是该示例的图形表示。

    Image for post
    Screen shot taken from Android Studio
    从Android Studio截取的屏幕截图

    Circular positioning : This helps to constrain the center of a widget (Let’s assume it to be Widget ‘A’)to the center of another widget (Let’s assume it to be Widget ‘B’) at a specific angle and a specific distance. The angle is provided with respect to a perpendicular imaginary line drawn upwards from the center of Widget A.

    圆形定位:这有助于以特定角度和特定距离将小部件的中心(假设其为小部件“ A”)约束到另一个小部件的中心(假设其为小部件“ B”) 。 相对于从小部件A的中心向上绘制的垂直假想线提供角度。

    attributes required to implement circular position

    实现圆形位置所需的属性

    app:layout_constraintCircle="[reference to another widget Id]"
    app:layout_constraintCircleRadius="[distance in dp]"
    app:layout_constraintCircleAngle="[the angle ranging from 0 to 360]"

    A pictorial representation of circular positioning is given below.

    下面给出了圆形定位的图示。

    Image for post
    Image for post
    circular positioning . Image source : Google’s Android developer docs.
    圆形定位。 图片来源:Google的Android开发人员文档。

    Dimension constraint : There is 3 ways to provide a dimension to a widget, a) We can hardcode the value of dimension in dp : Using a specific dimension (either a literal value such as 30 dp or a dimension reference)

    尺寸限制:有3种方法可为小部件提供尺寸:a)我们可以在dp中对尺寸值进行硬编码:使用特定尺寸(文字值(如30 dp或尺寸参考)

    b) WRAP_CONTENT : The widget with its dimension set to WRAP_CONTENT takes only the space that is needed. But while using WRAP_CONTENT, sometimes the widgets fails to follow the constraints.

    b)WRAP_CONTENT:其尺寸设置为WRAP_CONTENT的小部件仅占用所需的空间。 但是在使用WRAP_CONTENT时,有时小部件无法遵循约束。

    For example something like below

    例如下面的东西

    Image for post
    Image source : Screenshot from Android Studio
    图片来源:Android Studio的屏幕截图

    In the above case the material text view has been given the below attributes

    在上述情况下,材料文本视图具有以下属性

    android:layout_height="wrap_content"
    app:layout_constraintBottom_toTopOf="@+id/appCompatSpinner"

    but inspite of the constraint the text view is totally overlapping the spinner.

    但尽管有限制,文本视图仍与微调器完全重叠。

    hence to fight this situation , google has provided us with two very useful attributes , they are as follows :

    因此,为了应对这种情况,谷歌为我们提供了两个非常有用的属性,它们如下:

    • app:layout_constrainedWidth=”[boolean]”

      app:layout_constrainedWidth=”[boolean]”

    • app:layout_constrainedHeight=”[boolean]”

      app:layout_constrainedHeight=”[boolean]”

    The above attributes makes the widget follow the constraint whether it is vertical or horizontal.

    上面的属性使小部件无论是垂直还是水平都遵循约束。

    We also have below modifiers frequently used in conjection with WRAP_CONTENT -

    我们还具有以下经常与WRAP_CONTENT结合使用的修饰符-

    android:minWidth="[value in dp]"
    android:minHeight="[value in dp]"
    android:maxHeight="[value in dp]"
    android:maxWidth="[value in dp]"

    These modifiers are only valid with WRAP_CONTENT.

    这些修饰符仅对WRAP_CONTENT有效。

    c) MATCH_CONSTRAINT : The widget that specifies its dimension to MATCH_CONSTRAINT will take all the available space. We use 0 dp to represent MATCH_CONSTRAINT in Constraint Layout.

    c)MATCH_CONSTRAINT:将其尺寸指定为MATCH_CONSTRAINT的小部件将占用所有可用空间。 我们使用0 dp表示约束布局中的MATCH_CONSTRAINT。

    The MATCH_CONSTRAINT uses the below modifiers :

    MATCH_CONSTRAINT使用以下修饰符:

    app:layout_constraintWidth_max="[value in dp]"
    app:layout_constraintWidth_min="[value in dp]"
    app:layout_constraintHeight_max="[value in dp]"
    app:layout_constraintHeight_min="[value in dp]"

    Note : In Constraint Layout use of MATCH_PARENT is discouraged as it will not take constraint applied on a widget into consideration.

    注意:不鼓励在“约束布局”中使用MATCH_PARENT,因为它不会考虑对小部件施加的约束。

    Ratio : You can also define one dimension of a widget as a ratio of the other one. In order to do that, you need to have at least one constrained dimension be set to 0 dp (i.e., MATCH_CONSTRAINT), and set the attribute layout_constraintDimensionRatio to a given ratio. For example:

    比率:您还可以将小部件的一个尺寸定义为另一尺寸的比例。 为此,您需要至少将一个约束尺寸设置为0 dp(即MATCH_CONSTRAINT),并将属性layout_constraintDimensionRatio设置为给定比率。 例如:

    <Button android:layout_width="wrap_content"
    android:layout_height="0dp"
    app:layout_constraintDimensionRatio="1:1" />

    the above code will set the height of the button to be the same as its width.

    上面的代码将按钮的高度设置为与按钮的宽度相同。

    The ratio can be expressed either as:

    该比率可以表示为:

    • a float value, representing a ratio between width and height

      浮点值,表示宽度和高度之间的比率
    • a ratio in the form “width:height”

      比例形式为“宽度:高度”

    You can also use ratio if both dimensions are set to MATCH CONSTRAINT (0 dp). In this case the system sets the largest dimensions that satisfies all constraints and maintains the aspect ratio specified. To constrain one specific side based on the dimensions of another, you can pre append “ W," or “H,” to constrain the width or height respectively.

    如果两个尺寸都设置为MATCH CONSTRAINT(0 dp),则也可以使用比率。 在这种情况下,系统将设置满足所有约束并保持指定的宽高比的最大尺寸。 要基于另一侧的尺寸来约束一个特定的侧面,您可以预先附加“ W”或“ H”以分别约束其宽度或高度。

    For example, If one dimension is constrained by two targets (e.g. width is 0 dp and centered on parent) you can indicate which side should be constrained, by adding the letter W (for constraining the width) or H (for constraining the height) in front of the ratio, separated by a comma:

    例如,如果一个尺寸受两个目标约束(例如,宽度为0 dp并以父对象为中心),则可以通过添加字母W(用于约束宽度)或字母H (用于约束高度)来指示应约束哪一侧。在比率前面,用逗号分隔:

    <Button android:layout_width="0dp"
    android:layout_height="0dp"
    app:layout_constraintDimensionRatio="H,16:9"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintTop_toTopOf="parent"/>

    will set the height of the button following a 16:9 ratio, while the width of the button will match the constraints to parent.

    将按照16:9的比例设置按钮的高度,而按钮的宽度将使约束与父项匹配。

    Chains : It is used to create bidirectional connection between two or more widgets. Chains are basically an alternative to linear layout according to my observation. There are 3 different kind of chains available :

    链:用于在两个或多个小部件之间创建双向连接。 根据我的观察,链条基本上是线性布局的替代方案。 有3种不同的链可用:

    a) Spread : The widgets will be equidistant from each other and the margin.

    a)传播:小部件彼此之间以及边距等距。

    b) Spread inside : The widgets will be equidistant from each other and not the margin.

    b)散布在内部:小部件彼此等距,而不是边距。

    c) Packed : The widgets will be packed together closely.

    c)包装:小部件将紧密包装在一起。

    attributes used for the above chains :

    以上链使用的属性:

    app:layout_constraintHorizontal_chainStyle = "[spread/spread_inside/packed]"app:layout_constraintVertical_chainStyle = "[spread/spread_inside/packed]"

    Weighted chains : We can also have weighted chains , similar to weighted widgets inside a linear layout. For that we need to set the width/height to 0 dp as required.

    加权链:我们也可以有加权链,类似于线性布局中的加权小部件。 为此,我们需要根据需要将width / height设置为0 dp。

    attribute used for weighted chains :

    用于加权链的属性:

    app:layout_constraintHorizontal_weight = "[value in int]"app:layout_constraintVertical_weight = "[value in int]"
    Image for post
    Pictorial representation of Chain constraints , Image Source : Google’s Android developer docs.
    链约束的图示,图片来源:Google的Android开发者文档。

    虚拟助手对象: (Virtual helper Objects :)

    Virtual helper objects(VHOs) are views that are not displayed on device and are only used for creating a better layout. There are 3 basic VHOs:

    虚拟助手对象(VHO)是未在设备上显示的视图,仅用于创建更好的布局。 有3个基本的VHO:

    a) Guideline : It is a helper view that is used to perfectly align other views. Two Kinds of Guidelines are there Vertical Guideline and Horizontal Guideline.

    a) 准则:这是一个辅助视图,用于完美对齐其他视图。 垂直线和水平线有两种。

    Image for post
    A guideline to align three views , Image source: screenshot from Android Studio
    对齐三个视图的准则,图像来源:Android Studio的屏幕截图

    b) Barrier : This helper view references multiple widgets as input, and creates a virtual guideline based on the most extreme widget on the specified side.

    b) 障碍:此帮助程序视图引用多个窗口小部件作为输入,并根据指定侧最极端的窗口小部件创建虚拟准则。

    For Example :

    例如 :

    Let’s have two buttons, @id/button1 and @id/button2. With Barrier set to start we will have the following result.

    让我们有两个按钮,@ id / button1和@ id / button2。 将屏障设置为开始,我们将得到以下结果。

    Image for post
    Image source : Google’s Android developer docs.
    图片来源:Google的Android开发人员文档。

    The only difference between Barrier and Guideline is that Barrier’s position is flexible and always based on the size of multiple UI elements contained within it, whereas Guideline’s position is always fixed.

    BarrierGuideline之间的唯一区别是Barrier的位置是灵活的,并且始终基于其中包含的多个UI元素的大小,而Guideline的位置始终是固定的。

    c) Group : A Group is a VHO used to control the visibility of a group of views referenced together.

    c) 组:组是VHO,用于控制一起引用的一组视图的可见性。

    For example :

    例如 :

    <androidx.constraintlayout.widget.Group
    android:id="@+id/group"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:visibility="visible"
    app:constraint_referenced_ids="button4,button9" />

    结论: (Conclusion :)

    Constraint layout has solved many problems of layout creation. A layout built with it , if followed proper rules the layout actually adapts to different screen sizes. It also simplifies the creation of large and complex layouts. The main advantage of Constraint layout is it helps to create a flat view hierarchy. A flat view hierarchy is very beneficial in case of performance analysis.

    约束布局解决了布局创建的许多问题。 使用它构建的布局,如果遵循正确的规则,则该布局实际上会适应不同的屏幕尺寸。 它还简化了大型复杂布局的创建。 约束布局的主要优点是它有助于创建平面视图层次结构。 在性能分析的情况下,平面视图层次结构非常有用。

    To learn in more details , please check the official document for developer document for Constraint Layout.

    要了解更多详细信息,请在正式文档中查看约束布局的开发人员文档

    翻译自: https://medium.com/dev-genius/understanding-the-constraint-layout-in-android-3b1528f8ca9

    android 约束 布局

    展开全文
  • Android约束布局ConstraintLayout使用完全解析 Android约束布局ConstraintLayout使用完全解析
  • Android约束布局

    2019-07-09 15:53:54
    Android约束布局问世已经有一段时间了,对于最初的一些开发者来说,早已习惯了相对布局或线性布局的使用,基本上可以满足日常开发的需求。但是这样一来,约束布局不就没有它存在的意义了吗。 从谷歌官方数据来看,...

    Android约束布局问世已经有一段时间了,对于最初的一些开发者来说,早已习惯了相对布局或线性布局的使用,基本上可以满足日常开发的需求。但是这样一来,约束布局不就没有它存在的意义了吗。

    从谷歌官方数据来看,约束布局在某些情况下表现要高于线性布局以及相对布局。其特点是层级单一,所有控件均处于同一层级。

    学习时参考了这篇文章,写的不错。

    带你了解Android约束布局ConstraintLayout

     

    约束布局的强大

    1、圆形定位

    可以让一个控件以另一个控件的中心为中心点,来设置其相对与该中心点的距离和角度

    2、障碍

    当需要某一控件的位置是根据某几个控件宽度改变而改变时,可以设置某几个控件为一组,目标控件对这组控件设置障碍,从而达到效果。

    3、Guidelines

    在横纵两个方向上可以设置Guideline,其用于帮助控件约束时提供边界。如需要两个控件整体居中。则设置纵轴方向Guideline在50%地方,之后左右两边各一个控件既满足居中条件。

    4、自动添加约束

    自动添加约束的方式主要有两种,一种叫Autoconnect,一种叫Inference

    Autoconnect是生效后,下一个添加的控件自动添加约束。

    Inference是给当前页面内所有控件自动添加约束。

    注意自动添加约束不会百分百的准确,仍然需要我们进行手动调整。

    5、尺寸约束

    约束布局中不推荐使用MATCH_PARENT这个值,如果想满足效果,设置宽或高为0dp。

    6、宽高比

    通过layout_constraintDimensionRatio设置一个比例即可,如2:1 。若希望宽度充满全屏,高度按比例,则需要在前面加上"H",之后再加上比例。宽和高同时要设置0dp。

    7、百分百宽高

    百分比宽高为设置自身一个0到1之间的值,以自身为基数乘以比例。

    8、位置偏向

    可以设置位置偏向某一方向百分比。如偏左30%,即控件整体位置偏左30%。

    9、权重

    与线性布局一样,约束布局也可以设置权重

    10、链

    约束布局提供了5种链式结构,权重链就是其中一种。使用不同的结构可以达到不同的效果。

     

    展开全文
  • Android 约束布局

    2017-08-17 10:16:06
    闲来无事,干点啥好,突然想起了约束布局,学习一下吧 1.学习约束布局之前 所有布局靠xml手撸… 包含自定义控件,复杂布局处理 优点: 1. 直观,方便 2. 多年习惯 缺点: 1. 有些蛋疼布局会导致嵌套严重(存在过度绘制)...
  • 其中线性布局、相对布局平时更常用,这里学习另外一种常用布局——约束布局(constraintlayout) 约束布局特点 1.前面介绍的布局,虽然在AS中可以拖拽控件实现,但写代码更加方便,但是约束布局更加倾向通过拖拽...
  • ConstraintLayout约束布局
  • 约束布局ConstraintLayout加快布局速度

    千次阅读 2016-12-16 10:43:48
    Android Studio2.2更新布局设计器,同时,引人了约束布局ConstraintLayout。简单来说,可以把它看做是相对布局的升级版本,但是区别与相对布局更加强调约束。何为约束,即控件之间的关系。它能让你的布局更加扁平化...
  • 1. 引入 约束 布局 ( 1 ) 约束布局 作用 和 简介 2. 约束 简介 ( 1 ) 约束个数要求 ( 2 ) 约束设置 与 显示位置 3. ConstraintLayout 引入 ( 1 ) ConstraintLayout 依赖添加 ( 2 ) ConstraintLayout 转换 ...
  • ConstraintLayout约束布局简单使用

    千次阅读 2019-07-04 09:35:27
    ConstraintLayout约束布局的出现是为了简化布局嵌套,减少绘制时间,提高绘制效率,可以在api>9的Android机器上使用,更主要的是约束布局可以尽情地让你发挥拖拽的本领,在界面上添加约束,抛开繁琐的xml布局,...
  • 嵌套约束布局的时候不要在用约束布局 要进行高度的限制要不会 自适应高度
  • ConstraintLayout约束布局详解

    千次阅读 2018-07-04 16:53:05
    一、ConstraintLayout概述ConstraintLayout, 即约束布局, 是Google在去年的I/O大会上重点宣传的一个功能。从支持力度而言, 将成为主流布局样式, 代替其他布局, 减少布局的层级, 优化渲染性能. 在新版Android Studio...
  • 代码包含线性布局,框架布局,表格布局,相对布局,约束布局的基础使用。
  • 到深圳这边后比较忙,很久没有更新了,今天写的这篇博客是因为在面试的过程中问到了约束布局。 所以简单提一下约束布局。 这边文章会分为如下几点 1.ConstraintLayout是什么 2.为什么要用ConstraintLayout 3....
  • 约束布局ConstraintLayout看这一篇就够了
  • Android约束布局ConstraintLayout的使用

    千次阅读 2018-12-21 16:31:12
    Android约束布局ConstraintLayout的基本使用 约束布局ConstraintLayout面世已有很长一段时间了,但我一直没有关注这个Android 中继五大布局后的新布局的使用。近日在网友的讨论的强烈推荐下,尝试了ConstraintLayout...
  • Android 之约束布局

    千次阅读 2018-12-25 13:25:27
    约束布局 ConstraintLayout 是一个ViewGroup,主要解决布局嵌套过多,从而在布局加载时,就要耗费了许多内存,影响了项目的整体的一个客户体验感,以及屏幕适配。所以约束布局也是项目中,比不可少的部分! 这里有...
  • 使用constraintlayout约束布局的注意事项 约束布局作为Google官方力推的新型布局方式 , 通过简单的拖拉拽便能实现相对复杂的页面布局。但在国内,似乎大部分人都不愿意使用这种看起来简便的一种新型布局方式。笔者...
  • 约束布局(ConstraintLayout)的使用 背景 之前已经提到了六大基础布局的最常见的两种,其余四种百度都有完整的教程,不多提及了。但是在布局的最后想提一下这个突然崛起的约束布局。 很多人说现在使用线性布局...
  • 约束布局使用详解

    千次阅读 2020-07-13 16:01:19
    约束布局使用详解 一、前言 在一般的安卓开发中,编写界面需要很多嵌套,这会有一定的性能影响,这个时候就可以使用 ConstraintLayout 或 RelativeLayout来减少嵌套,简化布局深度。ConstraintLayot 类似 ...
  • 约束布局

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,827
精华内容 20,330
关键字:

约束布局