Dlaczego zagnieżdżone wagi źle wpływają na wydajność? Alternatywy?

Napisałem kilka plików układu, w których użyłem layout_weightatrybutu, aby utworzyć stosunek między różnymi widokami.

W pewnym momencie zaczynam otrzymywać ostrzeżenia o zagnieżdżonych wagach.

Zastanawiam się więc, dlaczego zagnieżdżone wagi są niekorzystne dla wydajności i czy istnieje bardziej efektywny sposób tworzenia stałego stosunku między wymiarami widoku, który można by wykorzystać dla różnych rozmiarów ekranu i który nie musi określać wielu wartości wymiarów dpi przez kilka plików układu (mam na myśli różne rozmiary ekranu).

Dziękuję Ci!

Zagnieżdżone wagi są niekorzystne dla wydajności, ponieważ:

Wagi układów wymagają dwukrotnego pomiaru widżetu. Gdy LinearLayout z niezerowymi wagami jest zagnieżdżony wewnątrz innego LinearLayout z niezerowymi wagami, liczba pomiarów rośnie wykładniczo.

Lepiej jest używać RelativeLayout i dostosowywać widok do miejsc innych widoków bez używania określonych wartości dpi.

Aktualizacja: Jak wiemy, biblioteka procentowego wsparcia jest przestarzała z poziomu API 26. ConstraintLayoutto nowy sposób na osiągnięcie tej samej płaskiej struktury XML.

Zaktualizowany projekt Github

Zaktualizowane próbki:

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

    <TextView
        android:id="@+id/fifty_thirty"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="#ffff8800"
        android:gravity="center"
        android:text="@string/fifty_fifty_text"
        android:textColor="@android:color/white"
        app:layout_constraintHeight_default="percent"
        app:layout_constraintHeight_percent="0.5"
        android:textSize="25sp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintWidth_default="percent"
        app:layout_constraintWidth_percent="0.5" />

    <TextView
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="#ffff5566"
        android:gravity="center"
        android:text="@string/fifty_fifty_text"
        android:textColor="@android:color/white"
        android:textSize="25sp"
        app:layout_constraintHeight_default="percent"
        app:layout_constraintHeight_percent="0.5"
        app:layout_constraintLeft_toRightOf="@id/fifty_thirty"
        app:layout_constraintTop_toBottomOf="@id/fifty_thirty"
        app:layout_constraintWidth_default="percent"
        app:layout_constraintWidth_percent="0.5" />

</android.support.constraint.ConstraintLayout>

Aktualizacja: Świetna wiadomość, biblioteka procentowa obsługi Androida rozwiązuje nasz problem z wydajnością i zagnieżdżoną, niechlujną wagąLinearLayout

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

Demo TUTAJ

Rozważ ten prosty układ, aby zademonstrować to samo.

<android.support.percent.PercentRelativeLayout
    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">
    <TextView
        android:id="@+id/fifty_huntv"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="#ff7acfff"
        android:text="20% - 50%"
        android:textColor="@android:color/white"
        app:layout_heightPercent="20%"
        app:layout_widthPercent="50%" />
    <TextView
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_toRightOf="@id/fifty_huntv"
        android:background="#ffff5566"
        android:text="80%-50%"
        app:layout_heightPercent="80%"
        app:layout_widthPercent="50%"
        />

</android.support.percent.PercentRelativeLayout>

Uniknięto degradacji wydajności zagnieżdżonej LinearLayoutz obciążeniami. Naprawdę niesamowite !!!.

Myślę (i prawdopodobnie będę za to podpalony), ale znowu myślę, że mój telefon ma czterordzeniowy procesor, który może konkurować (jeśli nie całkowicie zniszczyć) większość domowych komputerów PC.

Myślę też, że tego rodzaju możliwości sprzętowe to przyszłość telefonów.

Więc dochodzę do wniosku, że dopóki nie dasz się ponieść zagnieżdżeniu (w MHO układ nigdy nie powinien być głębszy niż 4 poziomy, a jeśli tak, to prawdopodobnie robisz to źle), twój telefon mógłby się mniej przejmować o posiadaniu ciężarów.

Jest wiele rzeczy, które możesz zrobić, a które będą miały znacznie większy wpływ na wydajność, niż martwienie się, że procesor wykona dodatkowe obliczenia.

(proszę zauważyć, że jestem trochę zabawny, więc nie traktuję niczego zbyt poważnie z tego postu, poza tym, że są inne rzeczy, które powinieneś najpierw zoptymalizować, a martwienie się o 2-3-poziomową wagę nie pomaga Twoje zdrowie)

Głównym powodem, dla którego zagnieżdżone wagi są złe, jest to, że kiedy układ ma dzieci z wagą, należy go zmierzyć dwukrotnie (myślę, że jest to wspomniane w ostrzeżeniu o kłaczkach). Oznacza to, że układ ważony, który zawiera również układ ważony, musi być mierzony czterokrotnie, a każda dodana „warstwa” wag zwiększa miary o potęgę dwa.

W ICS (poziom API 14) GridLayoutdodano, co pozwala na proste i „płaskie” rozwiązania dla wielu układów, które wcześniej wymagały wag. Jeśli tworzysz dla wcześniejszych wersji Androida, będziesz miał nieco trudniejszy czas na usunięcie ciężarów, ale użycie RelativeLayouti spłaszczenie jak największej części układu w tej kabinie zwykle usuwa wiele zagnieżdżonych obciążeń.

Istnieje proste rozwiązanie pozwalające uniknąć zagnieżdżonych układów LinearLayout z wagami - po prostu użyj Tablelayout z weightSum i zagnieżdżonym LinearLayout z weightSum - Tablelayout ma te same atrybuty co LinearLayout (orientacja, wagaSum, layout_weight itp.) I nie wyświetla komunikatu - „zagnieżdżone wagi mają zły wpływ na wydajność ”

Przykład:

 <TableLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:weightSum="1">

        <ImageView
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="0.8"/>


        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="0.2"
            android:orientation="horizontal"
            android:weightSum="1">


            <ImageView
                android:layout_height="match_parent"
                android:layout_width="0dp"
                android:layout_weight="0.4"/>

            <TextView
                android:layout_height="match_parent"
                android:layout_width="0dp"
                android:layout_weight="0.6"/>


            </LinearLayout>

    </TableLayout>

Myślę, że jedyną alternatywą jest utworzenie funkcji, która nazywałaby się onResume i ustawiałaby wszystkie rozmiary i pozycje. W każdym razie, według wagi możesz ustawić tylko rozmiary, ale bez dopełnienia (więc układy stają się jeszcze bardziej skomplikowane), bez textSize (niemożliwe jakoś to skompensować), nie mówiąc już o takich rzeczach jak liczba linii.