Mit einer Vorschau 1 von Android Studio 2.2 hat Google ein neues Layout in seiner Support-Bibliothek veröffentlicht : ConstraintLayout. Mit ConstraintLayout ist es einfacher, ein Design-Tool in Android Studio zu verwenden, aber ich habe keine Möglichkeit gefunden, relative Größen (Prozent oder 'Gewichte' wie in LinearLayout) zu verwenden. Gibt es eine Möglichkeit, die Einschränkungen basierend auf Prozenten zu definieren? ZB eine Ansicht 40% eines Bildschirms einnehmen lassen, einen Abstand von 20% zwischen den Ansichten erstellen und die Breite einer Ansicht auf 50% der Breite einer anderen Ansicht festlegen?

Sie können dies derzeit auf verschiedene Arten tun.

Eine besteht darin, Richtlinien zu erstellen (klicken Sie mit der rechten Maustaste auf den Entwurfsbereich und dann auf vertikale / horizontale Richtlinie hinzufügen). Sie können dann auf die "Kopfzeile" der Richtlinie klicken, um die Positionierung prozentual zu ändern. Schließlich können Sie Ansichten auf Richtlinien beschränken.

Eine andere Möglichkeit besteht darin, eine Ansicht mithilfe von Bias (Prozent) zu positionieren und dann andere Ansichten in dieser Ansicht zu verankern.

Wir haben jedoch darüber nachgedacht, wie prozentuale Dimensionen angeboten werden können. Ich kann kein Versprechen abgeben, aber wir möchten es hinzufügen.

Es kann nützlich sein, hier eine Kurzreferenz zu haben.

Platzierung von Ansichten

Verwenden Sie eine Richtlinie mit app:layout_constraintGuide_percentwie folgt aus :

<androidx.constraintlayout.widget.Guideline
    android:id="@+id/guideline"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    app:layout_constraintGuide_percent="0.5"/>

Und dann können Sie diese Richtlinie als Ankerpunkte für andere Ansichten verwenden.

oder

Verwenden Sie Bias mit app:layout_constraintHorizontal_biasund / oder app:layout_constraintVertical_bias, um die Ansichtsposition zu ändern, wenn der verfügbare Speicherplatz dies zulässt

<Button
    ...
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintHorizontal_bias="0.25"
    ...
    />

Größe der Ansichten

Ein weiterer prozentualer Wert ist die Höhe und / oder Breite der Elemente mit app:layout_constraintHeight_percentund / oder app:layout_constraintWidth_percent:

<Button
    ...
    android:layout_width="0dp"
    app:layout_constraintWidth_percent="0.5"
    ...
    />

Ab "ConstraintLayout1.1.0-beta1" können Sie Breiten und Höhen in Prozent definieren.

android:layout_width="0dp"
app:layout_constraintWidth_default="percent"
app:layout_constraintWidth_percent=".4"

Dadurch wird die Breite auf 40% der Bildschirmbreite festgelegt. Eine Kombination aus diesem und Richtlinien in Prozent ermöglicht es Ihnen, jedes gewünschte prozentuale Layout zu erstellen.

Mit der neuen Version von ConstraintLayout v1.1 können Sie jetzt Folgendes tun:

<Button
android:layout_width="0dp"
android:layout_height="0dp"
app:layout_constraintHeight_percent="0.2"
app:layout_constraintWidth_percent="0.65" />

Dadurch wird die Schaltfläche auf 20% der Höhe und 65% der Breite der übergeordneten Ansicht beschränkt.

Verwendung von Richtlinien

Die akzeptierte Antwort ist etwas unklar, wie Richtlinien verwendet werden sollen und wie der "Header" lautet.

Schritte

Fügen Sie zuerst eine Richtlinie hinzu.

Wählen Sie die Richtlinie aus oder verschieben Sie sie ein wenig, um die Einschränkungen sichtbar zu machen.

Klicken Sie dann auf den runden Kreis (die "Überschrift"), bis er zu einem Prozent wird. Sie können diesen Prozentsatz dann auf 50% oder was auch immer Sie möchten ziehen.

Danach können Sie Ihre Ansicht auf die Richtlinie beschränken, um einen bestimmten Prozentsatz des übergeordneten Elements (mithilfe match_constraintder Ansicht) festzulegen.

Die Richtlinie ist von unschätzbarem Wert - und die App: layout_constraintGuide_percent ist ein guter Freund ... Manchmal möchten wir jedoch Prozentsätze ohne Richtlinien. Jetzt ist es möglich, Gewichte zu verwenden :

android:layout_width="0dp"
app:layout_constraintHorizontal_weight="1"

Hier ist ein vollständigeres Beispiel, das eine Richtlinie mit zusätzlichen Gewichten verwendet :

<?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"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="16dp"
    tools:context="android.itomerbu.layoutdemo.MainActivity">

    <android.support.constraint.Guideline
        android:id="@+id/guideline"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal"
        app:layout_constraintGuide_percent="0.44"/>

    <Button
        android:id="@+id/btnThird"
        android:layout_width="0dp"
        app:layout_constraintHorizontal_weight="1"
        android:layout_height="wrap_content"
        android:text="@string/btnThird"
        app:layout_constraintLeft_toLeftOf="parent"
        android:layout_marginBottom="8dp"
        app:layout_constraintRight_toLeftOf="@+id/btnTwoThirds"
        app:layout_constraintBottom_toTopOf="@+id/guideline"
        android:layout_marginStart="8dp"
        android:layout_marginLeft="8dp"/>

    <Button
        android:id="@+id/btnTwoThirds"
        app:layout_constraintHorizontal_weight="2"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="@string/btnTwoThirds"
        app:layout_constraintBottom_toBottomOf="@+id/btnThird"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintLeft_toRightOf="@+id/btnThird"/>
</android.support.constraint.ConstraintLayout>

Mit dem ConstraintLayout v1.1.2 sollte die Dimension auf 0dpund dann die Attribute layout_constraintWidth_percentoder layout_constraintHeight_percentauf einen Wert zwischen 0 und 1 gesetzt werden, wie:

<!-- 50% width centered Button -->
<Button
    android:id="@+id/button"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintWidth_percent=".5" />

(Sie müssen ConstraintLayout 1.1.2 und die folgenden Versionen nicht festlegen app:layout_constraintWidth_default="percent"oder verwenden. app:layout_constraintHeight_default="percent")

Das Einschränken von Layout 1.0, mit dem eine Ansicht erstellt wird, nimmt einen Prozentsatz des Bildschirms ein, für den zwei Richtlinien erforderlich sind. In Constraint Layout 1.1 wurde dies vereinfacht, da Sie jede Ansicht einfach auf eine prozentuale Breite oder Höhe beschränken können.

Ist das nicht fantastisch? Alle Ansichten unterstützen die Attribute layout_constraintWidth_percent und layout_constraintHeight_percent. Dadurch wird die Einschränkung auf einen Prozentsatz des verfügbaren Speicherplatzes festgelegt. Das Erweitern einer Schaltfläche oder einer Textansicht, um einen Prozent des Bildschirms auszufüllen, kann mit wenigen XML-Zeilen erfolgen.

Wenn Sie beispielsweise die Breite der Schaltfläche auf 70% des Bildschirms einstellen möchten, können Sie dies folgendermaßen tun:

<Button
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_constraintWidth_percent="0.7" />

Bitte beachten Sie, dass Sie die Dimension als Prozentsatz für 0dp verwenden müssen, wie wir oben angegeben haben: layout_width bis 0dp.

Wenn Sie die Höhe der Schaltfläche auf 20% des Bildschirms einstellen möchten, können Sie dies folgendermaßen tun:

<Button
android:layout_width="wrap_content"
android:layout_height="0dp"
android:layout_constraintHeight_percent="0.2" />

Sehen! Wir haben diesmal android: layout_height auf 0dp angegeben, da die Schaltfläche die Höhe als Prozentsatz verwenden soll.

Versuchen Sie diesen Code. Sie können die Prozentsätze für Höhe und Breite mit app: layout_constraintHeight_percent und app: layout_constraintWidth_percent ändern.

<?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">

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="#FF00FF"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHeight_percent=".6"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintWidth_percent=".4"></LinearLayout>

</android.support.constraint.ConstraintLayout>

Gradle:

dependencies {
...
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
}

Sie können app:layout_constraintVertical_weightes genauso verwenden wie layout_weightinlinearlayout

<android.support.constraint.ConstraintLayout
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">

<Button
    android:id="@+id/button4"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:text="Button"
    app:layout_constraintLeft_toLeftOf="parent"
    app:layout_constraintRight_toLeftOf="@+id/button5"
    app:layout_constraintVertical_weight="1"/>

<Button
    android:id="@+id/button5"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:text="Button"
    app:layout_constraintLeft_toRightOf="@+id/button4"
    app:layout_constraintRight_toRightOf="parent"
    app:layout_constraintVertical_weight="1"/>
</android.support.constraint.ConstraintLayout>

HINWEIS: app:layout_constraintVertical_weight( app:layout_constraintHorizontal_weight) funktioniert mit android:layout_width="0dp"(android:layout_height="0dp"

Für jemanden, der nützlich sein könnte, können Sie layout_constraintDimensionRatioim jede untergeordnete Ansicht in einem verwenden ConstraintLayoutund wir können die Höhe oder Breite als Verhältnis der anderen Dimension definieren (mindestens eine muss 0 dp sein, entweder Breite oder Höhe)

 <ImageView
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        android:src="@drawable/top_image"
        app:layout_constraintDimensionRatio="16:9"        
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>

In diesem Fall beträgt das Seitenverhältnis 16: 9. app:layout_constraintDimensionRatio="16:9" Weitere Informationen finden Sie HIER

Ich weiß, dass dies nicht direkt das ist, wonach OP ursprünglich gefragt hat, aber dies hat mir in dieser Situation sehr geholfen, als ich eine ähnliche Frage hatte. Hinzufügen für Leute, die die Größe des Layoutfensters (das ich regelmäßig verwende) über Code ändern möchten . Fügen Sie dies Ihrem onCreate in der Aktivität der Frage hinzu. (Ändert es auf 80%)

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);

int width = dm.widthPixels;
int height = dm.heightPixels;

getWindow().setLayout((int)(width * 0.8), (int)(height * 0.8));

Einfach durch Ersetzen in Ihrem Richtlinien-Tag ersetzen

app:layout_constraintGuide_begin="291dp"

mit

app:layout_constraintGuide_percent="0.7"

wobei 0,7 70% bedeutet.

Auch wenn Sie jetzt versuchen, Richtlinien zu ziehen, wird der gezogene Wert jetzt in% Alter angezeigt.

Mithilfe von Richtlinien können Sie die Positionierung prozentual ändern

<android.support.constraint.Guideline
android:id="@+id/guideline"
android:layout_width="1dp"
android:layout_height="wrap_content"
android:orientation="vertical"
app:layout_constraintGuide_percent="0.5"/>

Sie können diesen Weg auch verwenden

android:layout_width="0dp"
app:layout_constraintWidth_default="percent"
app:layout_constraintWidth_percent="0.4"