Szerokość procentowa w relacji

To nie do końca odpowiada na pierwotne pytanie, które dotyczyło podziału 70/30, ale w szczególnym przypadku podziału 50/50 między Komponenty jest sposób: umieść niewidzialną rozpórkę na środku i użyj jej do umieszczenia dwóch interesujących elementów.

<RelativeLayout 
    android:layout_width="match_parent"
    android:layout_height="wrap_content">
    <View android:id="@+id/strut"
        android:layout_width="0dp"
        android:layout_height="0dp" 
        android:layout_centerHorizontal="true"/>
    <Button
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_alignRight="@id/strut"
        android:layout_alignParentLeft="true"
        android:text="Left"/> 
    <Button 
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@id/strut"
        android:layout_alignParentRight="true"
        android:text="Right"/>
</RelativeLayout>

Ogólnie jednak najlepiej nie oczekuj zbyt wiele od układów Android akcji...

Update 1

Jak wskazał @EmJiHash Procentrelativelayout jest przestarzały w API poziom 26.0.0

Poniżej cytując komentarz google:

Ta klasa była przestarzała w API na poziomie 26.0.0. zamiast tego rozważ użycie ConstraintLayout i powiązanych układów. Poniżej przedstawiono jak replikować funkcjonalność układów procentowych za pomocą ConstraintLayout

Google wprowadziło nowe API o nazwie android.wsparcie.procent

Następnie możesz po prostu określić procent do wzięcia przez Widok

Dodaj zależność kompilacji jak

implementation 'com.android.support:percent:22.2.0

W tym, Procentrelativelayout jest to, co możemy zrobić procent mądry układ

 <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">
     <ImageView
         app:layout_widthPercent="50%"
         app:layout_heightPercent="50%"
         app:layout_marginTopPercent="25%"
         app:layout_marginLeftPercent="25%"/>
 </android.support.percent.PercentRelativeLayout>

Nie można używać procentów do definiowania wymiarów widoku wewnątrz RelativeLayout. Najlepszym sposobem na to jest użycie LinearLayout i wag lub niestandardowego układu.

Możesz rzucić okiem na nową bibliotekę procent wsparcia.

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

Docs

Próbka

Możesz użyć Procentrelativelayout, jest to niedawny nieudokumentowany dodatek do biblioteki Design Support Library, umożliwia określenie nie tylko elementów względem siebie, ale także całkowitego procentu dostępnej przestrzeni.

Podklasa RelativeLayout, która obsługuje wymiary oparte na procentach i marginesy. Wymiar lub margines potomka można określić za pomocą atrybuty z przyrostkiem "procent".

<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">
  <ImageView
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      app:layout_widthPercent="50%"
      app:layout_heightPercent="50%"
      app:layout_marginTopPercent="25%"
      app:layout_marginLeftPercent="25%"/>
</android.support.percent.PercentFrameLayout>

Procent pakiet zawiera interfejsy API do obsługi dodawania i zarządzania wymiarami procentowymi w aplikacji.

Aby użyć, musisz dodać tę bibliotekę do listy zależności Gradle:

dependencies {
    compile 'com.android.support:percent:22.2.0'//23.1.1
}

Ponieważ Procentrelativelayout został wycofany w wersji 26.0.0 i zagnieżdżone układy, takie jak LinearLayout wewnątrz RelativeLayout, mają negatywny wpływ na wydajność (zrozumienie korzyści wydajności ConstraintLayout ), najlepszą opcją dla osiągnięcia szerokości procentowej jest zastąpienie RelativeLayout ConstraintLayout.

Rozwiązanie # 1 z wykorzystaniem wytycznych z procentem offset

<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/host_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Host"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/host_input" />

    <TextView
        android:id="@+id/port_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Port"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/host_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="textEmailAddress"
        app:layout_constraintTop_toBottomOf="@+id/host_label"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toLeftOf="@+id/guideline" />

    <EditText
        android:id="@+id/port_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="number"
        app:layout_constraintTop_toBottomOf="@+id/port_label"
        app:layout_constraintLeft_toLeftOf="@+id/guideline"
        app:layout_constraintRight_toRightOf="parent" />

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

</android.support.constraint.ConstraintLayout>

Rozwiązanie # 2 z wykorzystaniem łańcucha o ważonej szerokości dla EditText

<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/host_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Host"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/host_input" />

    <TextView
        android:id="@+id/port_label"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Port"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="8dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/host_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="textEmailAddress"
        app:layout_constraintHorizontal_weight="0.8"
        app:layout_constraintTop_toBottomOf="@+id/host_label"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toLeftOf="@+id/port_input" />

    <EditText
        android:id="@+id/port_input"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:layout_marginLeft="8dp"
        android:layout_marginRight="8dp"
        android:inputType="number"
        app:layout_constraintHorizontal_weight="0.2"
        app:layout_constraintTop_toBottomOf="@+id/port_label"
        app:layout_constraintLeft_toRightOf="@+id/host_input"
        app:layout_constraintRight_toRightOf="parent" />

</android.support.constraint.ConstraintLayout>

W obu przypadkach dostajesz coś takiego

Rozwiązałem to tworząc własny widok:

public class FractionalSizeView extends View {
  public FractionalSizeView(Context context, AttributeSet attrs) {
    super(context, attrs);
  }

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

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int width = MeasureSpec.getSize(widthMeasureSpec);
    setMeasuredDimension(width * 70 / 100, 0);
  }
}

To jest niewidzialna strut, której mogę użyć do wyrównania innych widoków w RelativeLayout.

Update

Jak wskazuje @EmJiHash PercentRelativeLayout i PercentFrameLayout jest przestarzały na poziomie API 26.0.0

Rozważ Użycie ConstraintLayout

Google wprowadziło nowe API o nazwie android.wsparcie.procent

1)Procentrelativelayout

2)PercentFrameLayout

Dodaj zależność kompilacji jak

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

Możesz określić wymiar w procentach, aby uzyskać oba korzyść RelativeLayout i procent

 <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
         app:layout_widthPercent="40%"
         app:layout_heightPercent="40%"
         app:layout_marginTopPercent="15%"
         app:layout_marginLeftPercent="15%"/>
 </android.support.percent.PercentRelativeLayout/>

Procentrelativelayout jest przestarzały z wersji 26.0.0 biblioteki wsparcia.

Google wprowadziło nowy Layout o nazwie ConstraintLayout .

Dodaj bibliotekę jako zależność w budowaniu na poziomie modułu.plik:

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

Wystarczy dodać w pliku układu:

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

Ograniczenia

Ograniczenia pomagają utrzymać zgodność widżetów. Możesz użyć kotwic, takich jak uchwyty ograniczające pokazane poniżej, aby określ reguły wyrównania między różnymi widżetami.

1. Wrap Content: widok rozszerza się w razie potrzeby, aby dopasować jego zawartość.
2. Match Constraints: widok rozszerza się w razie potrzeby, aby spełnić definicję jego ograniczeń po uwzględnieniu marginesów. Jeśli jednak dany wymiar ma tylko jedno ograniczenie, to Widok rozszerza się tak, aby pasował do jego zawartości. Korzystanie z tego trybu na wysokości lub szerokości pozwala również ustawić stosunek wielkości.
3. Fixed: podajesz określony wymiar w polu tekstowym poniżej lub poprzez zmianę rozmiaru widoku w edytorze.
4. Spread: widoki są równomiernie rozłożone (po uwzględnieniu marginesów). Jest to wartość domyślna.
5. Spread inside: pierwszy i ostatni Widok są przymocowane do ograniczeń na każdym końcu łańcucha, a reszta jest równomiernie rozłożona.
6. Weighted: gdy łańcuch jest ustawiony na spread lub spread inside, możesz wypełnić pozostałe miejsce, ustawiając jeden lub więcej widoków na "dopasuj ograniczenia" (0dp). Przez domyślnie przestrzeń jest równomiernie rozłożona między każdym widokiem ustawionym na "dopasuj ograniczenia", ale można przypisać wagę do każdego widoku za pomocą atrybutów layout_constraintHorizontal_weight i layout_constraintVertical_weight. Jeśli znasz layout_weight w układzie liniowym, działa to w ten sam sposób. Tak więc widok o najwyższej wadze otrzymuje największą ilość miejsca; widoki o tej samej wadze otrzymują taką samą ilość miejsca.
7. Packed: widoki są pakowane razem(po uwzględnieniu marginesów). Następnie można dostosować odchylenie całego łańcucha (lewo/prawo lub góra/dół), zmieniając odchylenie głowy łańcucha.
8. Center Horizontally or Center Vertically: aby szybko utworzyć łańcuch widoków, zaznacz je wszystkie, Kliknij prawym przyciskiem myszy jeden z widoków, a następnie wybierz środek w poziomie lub środek w pionie, aby utworzyć łańcuch w poziomie lub w pionie]}
9. Baseline alignment: Wyrównaj linię bazową tekstu widoku do linii bazowej tekstu innego widoku.
10. Constrain to a guideline: Możesz dodaj pionowe lub poziome wytyczne, do których możesz ograniczyć widoki, a wytyczne będą niewidoczne dla użytkowników aplikacji. Wytyczne można ustawić w obrębie układu w oparciu o jednostki dp lub procent, względem krawędzi układu.
11. Adjust the constraint bias: po dodaniu ograniczenia po obu stronach widoku (a rozmiar widoku dla tego samego wymiaru to "stała" lub "zawartość zawijania"), widok staje się wyśrodkowany między tymi dwoma ograniczeniami z domyślnym odchyleniem 50%. Możesz dostosować przesunięcie suwaka odchylenia w oknie Właściwości]}
12. Set size as a ratio: możesz ustawić rozmiar widoku na stosunek taki jak 16: 9, Jeśli co najmniej jeden z wymiarów widoku jest ustawiony na "dopasuj ograniczenia" (0dp).

Można to osiągnąć za pomocą wag układu. Waga dyktuje, jak nieodebrane części ekranu są podzielone. Nadaj każdemu Edittextowi layout_width równą 0 i pewną proporcjonalną wagę. To znaczy, daj jeden ciężar 2, a drugi ciężar 1, jeśli chcesz, aby pierwszy zajmował dwa razy więcej miejsca.

Co ciekawe, opierając się na odpowiedzi od @ olefevre, można nie tylko robić układy 50/50 z "niewidzialnymi rozpórkami", ale wszelkiego rodzaju layouty z udziałem mocy dwóch.

Na przykład, oto układ, który tnie szerokość na cztery równe części (właściwie trzy, o wagach 1, 1, 2):

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

    <View
        android:id="@+id/strut"
        android:layout_width="1dp"
        android:layout_height="match_parent"
        android:layout_centerHorizontal="true"
        android:background="#000000" />

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_toLeftOf="@+id/strut" >

        <View
            android:id="@+id/left_strut"
            android:layout_width="1dp"
            android:layout_height="match_parent"
            android:layout_toLeftOf="@+id/strut"
            android:layout_centerHorizontal="true"
            android:background="#000000" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignParentLeft="true"
            android:layout_alignRight="@+id/left_strut"
            android:text="Far Left" />

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true"
            android:layout_toRightOf="@+id/left_strut"
            android:text="Near Left" />
    </RelativeLayout>

        <Button
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@id/strut"
            android:layout_alignParentRight="true"
            android:text="Right" />

</RelativeLayout>

Po prostu umieść dwa hosty i port textviews w niezależnej linii poziomej i użyj android: layout_weight, aby utworzyć procent

Sprawdź https://github.com/mmin18/FlexLayout , którego można użyć procent lub java expression bezpośrednio w layout xml.

<EditText
    app:layout_left="0%"
    app:layout_right="60%"
    app:layout_height="wrap_content"/>
<EditText
    app:layout_left="prev.right+10dp"
    app:layout_right="100%"
    app:layout_height="wrap_content"/>