Android => lay-outs

Invoering

Een lay-out definieert de visuele structuur voor een gebruikersinterface, zoals een activiteit of widget.

Een lay-out wordt gedeclareerd in XML, inclusief schermelementen die erin verschijnen. Code kan aan de applicatie worden toegevoegd om de status van schermobjecten tijdens runtime te wijzigen, inclusief die in XML.

Syntaxis

android: d = "top | bottom | left | right | center_vertical | fill_vertical | center_horizontal | fill_horizontal | center | vullen | clip_vertical | clip_horizontal | start | end"
android: layout_gravity = "top | bottom | left | right | center_vertical | fill_vertical | center_horizontal | fill_horizontal | center | fill | clip_vertical | clip_horizontal | start | end"

Opmerkingen

LayoutParams en Layout_ Attributes

Prestatie-impact van het gebruik van RelativeLayouts bovenaan uw weergavehiërarchie

Zoals uitgelegd in dit artikel over prestaties in Android , vereist een RelativeLayout twee lay-outpassen om correct te kunnen worden weergegeven. Voor complexe weergavehiërarchieën kan dit een aanzienlijke invloed hebben op de prestaties. RelativeLayouts nesten maakt dit probleem nog erger, omdat elke RelativeLayout ervoor zorgt dat het aantal lay-outpassen omhoog gaat.

LinearLayout

De LinearLayout is een ViewGroup die zijn kinderen rangschikt in een enkele kolom of een enkele rij. De oriëntatie kan worden ingesteld door de methode setOrientation() aan te roepen of het xml-kenmerk android:orientation .

Verticale richting : android:orientation="vertical"

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@string/app_name" />

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@android:string/cancel" />

</LinearLayout>

Hier is een screenshot hoe dit eruit zal zien:

Horizontale oriëntatie : android:orientation="horizontal"

 <TextView
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:text="@string/app_name" />

 <TextView
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:text="@android:string/cancel" />

De LinearLayout ondersteunt ook het toewijzen van een gewicht aan individuele kinderen met het kenmerk android:layout_weight .

Relatieve layout

RelativeLayout is een ViewGroup die onderliggende weergaven in relatieve posities weergeeft. Standaard worden alle onderliggende weergaven linksboven in de lay-out getekend, dus u moet de positie van elke weergave definiëren met behulp van de verschillende lay-outeigenschappen die beschikbaar zijn via RelativeLayout.LayoutParams . De waarde voor elke lay-outeigenschap is ofwel een Boolean om een lay-outpositie in te schakelen ten opzichte van de bovenliggende RelativeLayout of een ID die verwijst naar een andere weergave in de lay-out waartegen de weergave moet worden geplaatst.

Voorbeeld:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/imageView"
        android:src="@mipmap/ic_launcher" />

    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/editText"
        android:layout_toRightOf="@+id/imageView"
        android:layout_toEndOf="@+id/imageView"
        android:hint="@string/hint" />

</RelativeLayout>

Hier is een screenshot hoe dit eruit zal zien:

Zwaartekracht en layout zwaartekracht

android: layout_gravity

android:layout_gravity wordt gebruikt om de positie van een element in het bovenliggende element in te stellen (bijvoorbeeld een onderliggende View in een Layout ).
Ondersteund door LinearLayout en FrameLayout

android: zwaartekracht

android:gravity wordt gebruikt om de positie van de inhoud in een element in te stellen (bijvoorbeeld een tekst in een TextView ).

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    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"
    android:orientation="vertical">

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:orientation="vertical"
        android:layout_gravity="left"
        android:gravity="center_vertical">

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/first"
            android:background="@color/colorPrimary"
            android:gravity="left"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/second"
            android:background="@color/colorPrimary"
            android:gravity="center"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/third"
            android:background="@color/colorPrimary"
            android:gravity="right"/>

    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:orientation="vertical"
        android:layout_gravity="center"
        android:gravity="center_vertical">

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/first"
            android:background="@color/colorAccent"
            android:gravity="left"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/second"
            android:background="@color/colorAccent"
            android:gravity="center"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/third"
            android:background="@color/colorAccent"
            android:gravity="right"/>

    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:orientation="vertical"
        android:layout_gravity="right"
        android:gravity="center_vertical">

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/first"
            android:background="@color/colorPrimaryDark"
            android:gravity="left"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/second"
            android:background="@color/colorPrimaryDark"
            android:gravity="center"/>

        <TextView
            android:layout_width="@dimen/fixed"
            android:layout_height="wrap_content"
            android:text="@string/third"
            android:background="@color/colorPrimaryDark"
            android:gravity="right"/>

    </LinearLayout>

</LinearLayout>

Die wordt als volgt weergegeven:

GridLayout

GridLayout, zoals de naam al doet vermoeden, is een lay-out die wordt gebruikt om weergaven in een raster te rangschikken. Een GridLayout verdeelt zich in kolommen en rijen. Zoals u in het onderstaande voorbeeld kunt zien, wordt het aantal kolommen en / of rijen opgegeven door de eigenschappen columnCount en rowCount . Als u weergaven aan deze lay-out toevoegt, wordt de eerste weergave toegevoegd aan de eerste kolom, de tweede weergave aan de tweede kolom en de derde weergave aan de eerste kolom van de tweede rij.

<?xml version="1.0" encoding="utf-8"?>
<GridLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    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"
    android:columnCount="2"
    android:rowCount="2">

    <TextView
        android:layout_width="@dimen/fixed"
        android:layout_height="wrap_content"
        android:text="@string/first"
        android:background="@color/colorPrimary"
        android:layout_margin="@dimen/default_margin" />

    <TextView
        android:layout_width="@dimen/fixed"
        android:layout_height="wrap_content"
        android:text="@string/second"
        android:background="@color/colorPrimary"
        android:layout_margin="@dimen/default_margin" />

    <TextView
        android:layout_width="@dimen/fixed"
        android:layout_height="wrap_content"
        android:text="@string/third"
        android:background="@color/colorPrimary"
        android:layout_margin="@dimen/default_margin" />

</GridLayout>

Procent lay-outs

2.3

De Percent Support Library biedt PercentFrameLayout en PercentRelativeLayout , twee ViewGroups die een gemakkelijke manier bieden om View- dimensies en marges op te geven in termen van een percentage van de totale grootte.

U kunt de procentuele ondersteuningsbibliotheek gebruiken door het volgende aan uw afhankelijkheden toe te voegen.

compile 'com.android.support:percent:25.3.1'

Als u een weergave wilt weergeven die het scherm horizontaal vult maar slechts de helft van het scherm verticaal, zou u het volgende doen.

<android.support.percent.PercentFrameLayout
    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">

    <FrameLayout
        app:layout_widthPercent="100%"
        app:layout_heightPercent="50%"
        android:background="@android:color/black" />

<android.support.percent.PercentFrameLayout>

U kunt de percentages ook definiëren in een afzonderlijk XML-bestand met code zoals:

<fraction name="margin_start_percent">25%</fraction>

En verwijs ernaar in uw lay-outs met @fraction/margin_start_percent .

Ze bevatten ook de mogelijkheid om een aangepaste beeldverhouding in te stellen via de app:layout_aspectRatio .
Hiermee kunt u slechts één dimensie instellen, zoals alleen de breedte, en de hoogte wordt automatisch bepaald op basis van de beeldverhouding die u hebt gedefinieerd, of het nu 4: 3 of 16: 9 is of zelfs een vierkant 1: 1 beeldverhouding.

Bijvoorbeeld:

 <ImageView
    app:layout_widthPercent="100%"
    app:layout_aspectRatio="178%"
    android:scaleType="centerCrop"
    android:src="@drawable/header_background"/>

FrameLayout

FrameLayout is ontworpen om een gebied op het scherm te blokkeren om een enkel item weer te geven. U kunt echter meerdere kinderen aan een FrameLayout toevoegen en hun positie binnen de FrameLayout bepalen door aan elk kind de zwaartekracht toe te wijzen met behulp van het kenmerk android: layout_gravity .

In het algemeen wordt FrameLayout gebruikt om een enkele onderliggende weergave te bevatten. Gebruikelijke gevallen zijn het maken van plaatshouders voor het opblazen van Fragments in Activity , overlappende weergaven of het toepassen van voorgrond op de aanzichten.

Voorbeeld:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">

    <ImageView
        android:src="@drawable/nougat"
        android:scaleType="fitCenter"
        android:layout_height="match_parent"
        android:layout_width="match_parent"/>

    <TextView
        android:text="FrameLayout Example"
        android:textSize="30sp"
        android:textStyle="bold"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:gravity="center"/>

</FrameLayout>

Het ziet er zo uit:

CoordinatorLayout

2.3

De CoordinatorLayout is een container die enigszins lijkt op FrameLayout maar met extra mogelijkheden wordt het superkrachtige FrameLayout in de officiële documentatie.

Door een CoordinatorLayout.Behavior te koppelen aan een rechtstreeks onderliggende persoon van CoordinatorLayout, kunt u aanraakgebeurtenissen, vensterinzet, metingen, lay-out en genest scrollen onderscheppen.

Om het te gebruiken, moet u eerst een afhankelijkheid voor de ondersteuningsbibliotheek in uw gradle-bestand toevoegen:

compile 'com.android.support:design:25.3.1'

Het nummer van de laatste versie van de bibliotheek kunnen worden gevonden hier

Een praktisch gebruik van de CoordinatorLayout is het maken van een weergave met een FloatingActionButton . In dit specifieke geval maken we een RecyclerView met een SwipeRefreshLayout en een FloatingActionButton . Hier is hoe je dat kunt doen:

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/coord_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">

    <android.support.v4.widget.SwipeRefreshLayout
        android:id="@+id/swipe_refresh_layout"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <android.support.v7.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/recycler_view"/>

    </android.support.v4.widget.SwipeRefreshLayout>

    <android.support.design.widget.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="16dp"
        android:clickable="true"
        android:color="@color/colorAccent"
        android:src="@mipmap/ic_add_white"
        android:layout_gravity="end|bottom"
        app:layout_anchorGravity="bottom|right|end"/>

</android.support.design.widget.CoordinatorLayout>

Merk op hoe de FloatingActionButton is verankerd in de CoordinatorLayout met app:layout_anchor="@id/coord_layout"

Coördinator Lay-out Scrollen Gedrag

2.3-2.3.2

Een omhullende CoordinatorLayout kan worden gebruikt om Material Design Scrolling-effecten te bereiken bij gebruik van binnenste lay-outs die Nested Scrolling ondersteunen, zoals NestedScrollView of RecyclerView .

Voor dit voorbeeld:

app:layout_scrollFlags="scroll|enterAlways" wordt gebruikt in de werkbalkeigenschappen
app:layout_behavior="@string/appbar_scrolling_view_behavior" wordt gebruikt in de ViewPager-eigenschappen
Een RecyclerView wordt gebruikt in de ViewPager-fragmenten

Hier is het lay-out xml-bestand dat in een activiteit wordt gebruikt:

<android.support.design.widget.CoordinatorLayout
    android:id="@+id/main_layout"
    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"
    tools:context=".MainActivity">


    <android.support.design.widget.AppBarLayout
        android:id="@+id/appBarLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:elevation="6dp">
    <android.support.v7.widget.Toolbar
        android:id="@+id/toolbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:background="?attr/colorPrimary"
        android:minHeight="?attr/actionBarSize"
        android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"
        app:popupTheme="@style/ThemeOverlay.AppCompat.Light"
        app:elevation="0dp"
        app:layout_scrollFlags="scroll|enterAlways"
        />

    <android.support.design.widget.TabLayout
        android:id="@+id/tab_layout"
        app:tabMode="fixed"
        android:layout_below="@+id/toolbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="?attr/colorPrimary"
        app:elevation="0dp"
        app:tabTextColor="#d3d3d3"
        android:minHeight="?attr/actionBarSize"
        />

    </android.support.design.widget.AppBarLayout>

    <android.support.v4.view.ViewPager
        android:id="@+id/viewpager"
        android:layout_below="@+id/tab_layout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_behavior="@string/appbar_scrolling_view_behavior"
        />

</android.support.design.widget.CoordinatorLayout>

Resultaat:

Bekijk gewicht

Een van de meest gebruikte kenmerken voor LinearLayout is het gewicht van de onderliggende weergaven. Gewicht bepaalt hoeveel ruimte een weergave zal verbruiken in vergelijking met andere weergaven binnen een LinearLayout.

Gewicht wordt gebruikt wanneer u specifieke schermruimte wilt geven aan het ene onderdeel in vergelijking met het andere.

Sleutel eigenschappen :

weightSum is de algehele som van gewichten van alle weightSum . Als u het weightSum niet opgeeft, weightSum het systeem de som van alle gewichten zelf.
layout_weight geeft de hoeveelheid ruimte aan van de totale gewichtssom die de widget zal innemen.

Code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    android:weightSum="4">

    <EditText
        android:layout_weight="2"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="Type Your Text Here" />

    <Button
        android:layout_weight="1"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="Text1" />

    <Button
        android:layout_weight="1"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:text="Text1" />

</LinearLayout>

De output is:

Zelfs als het apparaat groter is, neemt de EditText 2/4 van de ruimte op het scherm in beslag. Vandaar dat het uiterlijk van uw app op alle schermen consistent is.

Opmerking: hier wordt de layout_width gehouden omdat de 0dp horizontaal wordt verdeeld. Als de widgets verticaal moeten worden uitgelijnd, wordt layout_height ingesteld op 0dp . Dit wordt gedaan om de efficiëntie van de code te verhogen, omdat het systeem tijdens runtime niet zal proberen de breedte of hoogte te berekenen, omdat dit wordt beheerd door het gewicht. Als u in plaats daarvan wrap_content gebruikt, wrap_content het systeem eerst de breedte / hoogte te berekenen voordat het gewichtsattribuut wordt toegepast, wat een nieuwe berekeningscyclus veroorzaakt.

LinearLayout programmatisch maken

Hiërarchie

- LinearLayout(horizontal)
   - ImageView
   - LinearLayout(vertical)
     - TextView
     - TextView

Code

LinearLayout rootView = new LinearLayout(context);
rootView.setLayoutParams(new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
rootView.setOrientation(LinearLayout.HORIZONTAL);

// for imageview
ImageView imageView = new ImageView(context);
// for horizontal linearlayout
LinearLayout linearLayout2 = new LinearLayout(context);
linearLayout2.setLayoutParams(new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));
linearLayout2.setOrientation(LinearLayout.VERTICAL);    

TextView tv1 = new TextView(context);
TextView tv2 = new TextView(context);
// add 2 textview to horizontal linearlayout
linearLayout2.addView(tv1);
linearLayout2.addView(tv2);

// finally, add imageview and horizontal linearlayout to vertical linearlayout (rootView) 
rootView.addView(imageView);
rootView.addView(linearLayout2);

LayoutParams

Elke afzonderlijke ViewGroup (bijv. LinearLayout , RelativeLayout , CoordinatorLayout , enz.) LinearLayout informatie opslaan over de eigenschappen van de kinderen. Over de manier waarop de kinderen worden ViewGroup in de ViewGroup . Deze informatie wordt opgeslagen in objecten van een wrapper-klasse ViewGroup.LayoutParams .

ViewGroups gebruikt subklassen van de klasse ViewGroup.LayoutParams om parameters op te nemen die specifiek zijn voor een bepaald lay- ViewGroup.LayoutParams .

Bijv. Voor

LinearLayout het is LinearLayout.LayoutParams
RelativeLayout het is RelativeLayout.LayoutParams
CoordinatorLayout het is CoordinatorLayout.LayoutParams
...

De meeste ViewGroups de mogelijkheid om margins voor hun kinderen in te stellen, zodat ze ViewGroup.LayoutParams rechtstreeks in subklasse ViewGroup.LayoutParams , maar in plaats daarvan ViewGroup.MarginLayoutParams (die zelf een subklasse is van ViewGroup.LayoutParams ).

LayoutParams in xml

LayoutParams objecten worden gemaakt op basis van het opgeblazen layout- xml bestand.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="50dp"
        android:layout_gravity="right"
        android:gravity="bottom"
        android:text="Example text"
        android:textColor="@android:color/holo_green_dark"/>

    <ImageView
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="@android:color/holo_green_dark"
        android:scaleType="centerInside"
        android:src="@drawable/example"/>

</LinearLayout>

Alle parameters die beginnen met layout_ specificeren hoe de omsluitende lay-out zou moeten werken. Wanneer de lay-out wordt opgeblazen, worden die parameters ingepakt in een geschikt LayoutParams object, dat later door de Layout zal worden gebruikt om een bepaalde View correct in de ViewGroup . Andere attributen van een View zijn direct aan de View gerelateerd en worden verwerkt door de View zelf.

Voor TextView :

layout_width , layout_height en layout_gravity worden opgeslagen in een LinearLayout.LayoutParams object en gebruikt door de LinearLayout
gravity , text en textColor worden gebruikt door de TextView zelf

Voor ImageView :

layout_width , layout_height en layout_weight worden opgeslagen in een LinearLayout.LayoutParams object en gebruikt door de LinearLayout
background , scaleType en src worden gebruikt door de ImageView zelf

Object LayoutParams verkrijgen

getLayoutParams is een methode van View's waarmee een huidig LayoutParams object kan worden opgehaald.

Omdat het LayoutParams object direct gerelateerd is aan de omringende ViewGroup , retourneert deze methode alleen een niet-nulwaarde wanneer View is gekoppeld aan de ViewGroup . U moet niet vergeten dat dit object mogelijk niet altijd aanwezig is. Vooral moet je er niet op vertrouwen dat je het in View's constructor hebt.

public class ExampleView extends View {
    
    public ExampleView(Context context) {
        super(context);
        setupView(context);
    }

    public ExampleView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setupView(context);
    }

    public ExampleView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setupView(context);
    }

    private void setupView(Context context) {
        if (getLayoutParams().height == 50){  // DO NOT DO THIS!
                                              // This might produce NullPointerException
            doSomething();
        }
    }
    
    //...
}

Als u afhankelijk wilt zijn van het hebben van het LayoutParams object, moet u in plaats daarvan de onAttachedToWindow gebruiken.

public class ExampleView extends View {

    public ExampleView(Context context) {
        super(context);
    }

    public ExampleView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public ExampleView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
        if (getLayoutParams().height == 50) { // getLayoutParams() will NOT return null here
            doSomething();
        }
    }

    //...
}

Casting LayoutParams object

Mogelijk moet u functies gebruiken die specifiek zijn voor een bepaalde ViewGroup (u wilt bijvoorbeeld de regels van een RelativeLayout programmatisch wijzigen). Voor dat doel moet u weten hoe u het ViewGroup.LayoutParams object correct kunt casten.

Dit kan een beetje verwarrend zijn bij het LayoutParams een LayoutParams object voor een onderliggende View die eigenlijk een andere ViewGroup .

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:id="@+id/outer_layout"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">

    <FrameLayout
        android:id="@+id/inner_layout"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:layout_gravity="right"/>

</LinearLayout>

BELANGRIJK: Het type LayoutParams object is direct gerelateerd aan het type van de ENCLOSING ViewGroup .

Onjuiste casting :

FrameLayout innerLayout = (FrameLayout)findViewById(R.id.inner_layout);
FrameLayout.LayoutParams par = (FrameLayout.LayoutParams) innerLayout.getLayoutParams();
                                          // INCORRECT! This will produce ClassCastException

Juiste casting :

FrameLayout innerLayout = (FrameLayout)findViewById(R.id.inner_layout);
LinearLayout.LayoutParams par = (LinearLayout.LayoutParams) innerLayout.getLayoutParams();
                                         // CORRECT! the enclosing layout is a LinearLayout

Modified text is an extract of the original Stack Overflow Documentation

Licentie onder CC BY-SA 3.0

Niet aangesloten bij Stack Overflow

Android
lay-outs

Zoeken…