linearlayout - Differenza tra gravità e layout_gravity su Android

linearlayout layoutparams android (13)

So che possiamo impostare i seguenti valori per android:gravity e android:layout_gravity proprietà android:layout_gravity :

center
center_vertical
center_horizontal , ecc.

Ma sono confuso riguardo a entrambi.

Qual è la differenza tra l'uso di android:gravity e android:layout_gravity ?

La differenza

android:layout_gravity è la gravità esterna della vista. Specifica la direzione in cui la vista deve toccare il bordo del genitore.

android:gravity è la gravità interiore di quella vista. Specifica in quale direzione deve essere allineato il suo contenuto.

Equivalenti HTML / CSS

Android                 | CSS
————————————————————————+————————————
android:layout_gravity  | float
android:gravity         | text-align

Facile trucco per aiutarti a ricordare

Prendi la layout-gravity come "Lay-outside-gravity".

C'è molta differenza nella gravity e nella gravity layout-gravity . Ho intenzione di spiegare la mia esperienza su questi 2 concetti ( tutte le informazioni che ho ricevuto grazie alla mia osservazione e ad alcuni siti Web ).

Uso di gravità e gravità del layout in FrameLayout .....

Nota:-

Gravity è utilizzato all'interno del contenuto della vista poiché alcuni utenti hanno una risposta ed è uguale per tutto il ViewGroup Layout .
Layout-gravity viene utilizzato con la vista padre come alcuni hanno risposto.
Gravity and Layout-gravity è il lavoro più utile con i FrameLayout . We can't use Gravity and Layout-gravity nel Tag di FrameLayout ....
Possiamo impostare Child View in qualsiasi punto del FrameLayout usando layout-gravity .
Possiamo utilizzare ogni singolo valore di gravità all'interno di FrameLayout (ad esempio: center_vertical , center_horizontal , center , top , ecc.), Ma non è possibile con altri layout di ViewGroup.
FrameLayout completamente funzionante su Layout-gravity . Esempio: - Se lavori su FrameLayout , non è necessario modificare l'intero layout per aggiungere una nuova vista. Basta aggiungere Visualizza come ultimo nel FrameLayout e attribuirgli un valore di gravità del layout (si tratta di adavantages di gravità del layout con FrameLayout ).

guarda l'esempio ......

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

    <TextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center"
        android:text="Center Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#1b64b9"
        android:gravity="bottom"
        android:layout_gravity="bottom|center"
        android:text="Bottom Layout Gravity" />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#d75d1c"
        android:gravity="top"
        android:layout_gravity="top|center"
        android:text="Top Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="100dp"
        android:textColor="#d71f1c"
        android:gravity="top|right"
        android:layout_gravity="top|right"
        android:text="Top Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="bottom"
        android:gravity="bottom"
        android:text="Top Left Layout Gravity"/>

</FrameLayout>

Produzione:-

Uso di gravità e gravità del layout in LinearLayout .....

Gravity funziona come sopra ma qui la differenza è che possiamo usare la gravità all'interno della LinearLayout View e della RelativeLayout View che non è possibile in FrameLayout View .

LinearLayout con orientamento verticale ....

Nota: - Qui possiamo impostare solo 3 valori di layout_gravity che sono ( left | right | center (anche chiamato center_horizontal )).

dare un'occhiata all'esempio: -

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

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:text="Center Layout Gravity \nor \nCenter_Horizontal"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="right"
        android:text="Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:gravity="bottom"
        android:text="Left Layout Gravity"/>

</LinearLayout>

Produzione:-

LinearLayout con orientamento orizzontale ....

Nota: - Qui possiamo impostare anche 3 valori di layout_gravity che sono (in top | in bottom | al center (chiamato anche center_vertical )).

dare un'occhiata all'esempio: -

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

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="bottom"
        android:text="Bottom \nLayout \nGravity"/>

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="center"
        android:text="Center \nLayout \nGravity"/>


    <TextView
        android:layout_width="150dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:text="Left \nLayout \nGravity"/>

</LinearLayout>

produzione:-

Nota: - Non possiamo usare layout_gravity nelle RelativeLayout Views ma possiamo usare la gravity per impostare i child RelativeLayout nella stessa posizione ....

Gravity viene utilizzato per impostare l'allineamento del testo nelle viste, ma layout_gravity viene utilizzato per impostare le visualizzazioni in modo autonomo. Prendiamo un esempio se si desidera allineare il testo scritto in editText, quindi utilizzare la gravità e si desidera allineare questo editText o qualsiasi pulsante o qualsiasi vista, quindi utilizzare layout_gravity, quindi è molto semplice.

Ho solo pensato di aggiungere qui la mia spiegazione - proveniente da uno sfondo su iOS, questo è il modo in cui ho interiorizzato i due in termini iOS: "Gravità del layout" influenza la tua posizione nella superview. "Gravity" influenza la posizione delle tue sottoview in te. Detto in un altro modo, Layout Gravity ti posiziona mentre la gravità posiziona i tuoi figli.

La differenza fondamentale tra i due è che-

android: la gravità viene utilizzata per elementi figlio della vista.

android: layout_gravity è usato per questo elemento rispetto alla vista genitore.

Qualcosa che ho visto sul blog di Sandip che ho quasi perso, ha risolto il mio problema. Ha detto che layout_gravity NON FUNZIONA CON LinearLayout .

Se stai usando un LinearLayout e le impostazioni di gravità ti stanno facendo impazzire (come me), passa a qualcos'altro.

In realtà sono passato a un RelativeLayout quindi layout_alignParentLeft usato layout_alignParentLeft e layout_alignParentRight sui 2 TextView contenuti per farli su una riga per andare a sinistra e all'estrema destra.

Se vogliamo impostare la gravità del contenuto all'interno di una vista, useremo "android: gravità", e se vogliamo impostare la gravità di questa vista (nel suo insieme) all'interno della sua vista genitore, useremo "android: layout_gravity".

Sebbene la domanda abbia già una risposta, ho alcuni esempi che dimostrano l'uso della gravità, layout_gravity e layout_weight.

Puoi trovare gli esempi su http://juanpickselov.com/LayoutExamples.zip

Ho creato i file in Eclipse, rimosso le sottocartelle .svn e ho incluso stili, stringhe, colori, ecc. I file di layout sono il punto principale delle demo. Dal momento che sono un principiante di sviluppo Java e Android, è possibile che Java sia inefficiente. I file possono essere copiati in un progetto Eclipse o li ho anche usati in Netbeans con il plugin di sviluppo Android disponibile per quell'IDE.

Dentro fuori

gravity organizza il contenuto all'interno della vista.
lay out _gravity organizza la posizione della vista al di fuori di se stessa.

A volte aiuta anche a vedere una foto. Il verde e il blu sono TextViews e gli altri due colori di sfondo sono LinearLayouts .

Gli appunti

layout_gravity non funziona per le viste in un RelativeLayout . Usalo per le viste in un LinearLayout o FrameLayout . Vedi la mia risposta supplementare per maggiori dettagli.
La larghezza (o l'altezza) della vista deve essere maggiore del suo contenuto. Altrimenti la gravity non avrà alcun effetto. Quindi, wrap_content e gravity hanno significato insieme.
La larghezza (o l'altezza) della vista deve essere inferiore al genitore. Altrimenti layout_gravity non avrà alcun effetto. Pertanto, match_parent e layout_gravity hanno significato insieme.
Il layout_gravity=center lo stesso aspetto di layout_gravity=center_horizontal perché si trovano in un layout lineare verticale. In questo caso non puoi centrare verticalmente, quindi layout_gravity=center centra solo orizzontalmente.
Questa risposta ha riguardato solo l'impostazione di gravity e layout_gravity sulle viste all'interno di un layout. Per vedere cosa succede quando si imposta la gravity del layout genitore stesso, controlla la risposta supplementare che ho citato sopra. (Riepilogo: la gravity non funziona bene su un RelativeLayout ma può essere utile con un LinearLayout .)

Quindi ricorda, layout _gravity organizza una vista nel suo layout . Gravity organizza il contenuto all'interno della vista.

xml

Ecco l'xml per l'immagine sopra per il tuo riferimento:

<?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:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#e3e2ad"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="left"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center_horizontal"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="right"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center"
            android:text="center" />

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#d6c6cd"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="layout_gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="left"
            android:background="#bcf5b1"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center_horizontal"
            android:background="#aacaff"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="right"
            android:background="#bcf5b1"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center"
            android:background="#aacaff"
            android:text="center" />

    </LinearLayout>

</LinearLayout>

Relazionato

Differenza tra riempimento e margine di una vista
Match_parent vs wrap_content
Come impostare sia la gravità che la gravità del layout di un LinearLayout in modo programmatico

android:gravity -> Imposta la gravità del contenuto della vista su cui è utilizzato.

android:layout_gravity -> Imposta la gravità della vista o del layout del genitore

Gravità: consente di spostare il contenuto all'interno di un contenitore. (Come verranno posizionate le sotto-viste).

Importante: (spostare lungo l'asse X o l'asse Y entro lo spazio disponibile).

Esempio: diciamo che se dovessi lavorare con LinearLayout (Height: match_parent, Width: match_parent) come elemento di livello root, avrai a disposizione lo spazio completo sul fotogramma; e le viste secondarie dicono che 2 TextView (altezza: wrap_content, larghezza: wrap_content) all'interno di LinearLayout possono essere spostate lungo l'asse x / y utilizzando i valori corrispondenti per gravità sul genitore.

Layout_Gravity: consente di ignorare il comportamento gravitazionale genitore SOLO lungo l'asse x.

Importante: (MOVE [override] lungo l'asse X all'interno dello spazio disponibile).

Esempio: se tenga presente l'esempio precedente, sappiamo che la gravità ci ha permesso di spostarci lungo l'asse x / y, cioè; il posto TextViews all'interno di LinearLayout. Diciamo solo che LinearLayout specifica gravità: centro; il che significa che ogni TextView deve essere centrale sia verticalmente che orizzontalmente. Ora se vogliamo che uno di TextView vada a sinistra / destra, possiamo sovrascrivere il comportamento gravitazionale specificato usando layout_gravity sul TextView.

Bonus: se scorri più a fondo, scoprirai che il testo all'interno di TextView funge da sottovista; quindi se applichi la gravità su TextView, il testo all'interno di TextView si muoverà. (l'intero concetto si applica anche qui)

gravità : è usato per visualizzazioni semplici come textview, edittext ecc.

layout_gravity : è usato per la vista corrente solo per gravità nel contesto della relativa vista genitore come Layout lineare o FrameLayout per rendere la vista al centro o qualsiasi altra gravità del suo genitore.

android:gravity

viene utilizzato per regolare il contenuto della vista rispetto alla sua posizione specifica (area allocata). android:gravity="left" non farebbe nulla se layout_width è uguale al "wrap_content"

android:layout_gravity

viene utilizzato per la visualizzazione stessa rispetto al file principale o di layout.