Wiem, omawiano to już 1000 razy, ale nie mogę dostosować rozmiaru tekstu do różnych rozmiarów ekranu. Próbuję użyć „sp” jako jednostek rozmiaru w moim niestandardowym stylu:

<style name="CustumButtonStyle" parent="@android:style/Widget.Button">
    ...
    <item name="android:textSize">30sp</item>
    ...
</style>

W 2.7 QVGA wygląda dobrze:

Ale w 7-calowym WSVGA wygląda to tak:

Próbowałem użyć zarówno „sp”, jak i „dp” z tym samym wynikiem.

Czy mógłbyś wyjaśnić, jak sprawić, by te przyciski wyglądały tak samo na każdym ekranie?

W pełni niestandardowy styl przycisków

<style name="CustumButtonStyle" parent="@android:style/Widget.Button">
    <item name="android:background">@drawable/custom_button</item>
    <item name="android:layout_width">fill_parent</item>
    <item name="android:layout_height">wrap_content</item>
    <item name="android:layout_margin">3dp</item>
    <item name="android:textColor">#ffffff</item>
    <item name="android:gravity">center</item>
    <item name="android:textSize">30sp</item>
    <item name="android:textStyle">bold</item>
    <item name="android:shadowColor">#000000</item>
    <item name="android:shadowDx">1</item>
    <item name="android:shadowDy">1</item>
    <item name="android:shadowRadius">2</item>
</style>

I w moim motywie aplikacji mam

<item name="android:buttonStyle">@style/CustumButtonStyle</item>

A oto mój układ:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/RelativeLayout1"
android:layout_width="fill_parent"
android:background="@drawable/grid"
android:gravity="center"
android:orientation="vertical" android:layout_height="fill_parent">

<Button
    android:id="@+id/buttonContinue"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true"
    android:layout_gravity="center"
    android:gravity="center"
    android:text="@string/continue_game" android:layout_marginTop="3dp" android:layout_marginBottom="3dp"/>



<Button
    android:id="@+id/buttonNewGame"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignLeft="@+id/buttonContinue"
    android:layout_alignRight="@+id/buttonContinue"
    android:layout_below="@+id/buttonContinue"
    android:layout_gravity="center"
    android:gravity="center"
    android:text="@string/new_game" android:layout_marginTop="3dp" android:layout_marginBottom="3dp"/>



<Button
    android:id="@+id/ButtonAbout"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignLeft="@+id/buttonNewGame"
    android:layout_alignRight="@+id/buttonNewGame"
    android:layout_below="@+id/buttonNewGame"
    android:layout_gravity="center"
    android:gravity="center"
    android:text="@string/about" android:layout_marginTop="3dp" android:layout_marginBottom="3dp"/>

@forcelain Myślę, że musisz sprawdzić ten plik PDF Google IO for Design . W tym pliku pdf przejdź do strony nr: 77, na której znajdziesz sugestie użycia dimens.xml dla różnych urządzeń z Androidem. Przykład patrz poniższa struktura:

res/values/dimens.xml

res/values-small/dimens.xml

res/values-normal/dimens.xml

res/values-large/dimens.xml

res/values-xlarge/dimens.xml

na przykład użyłeś poniżej dimens.xml w wartościach.

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">18sp</dimen>
</resources>

W folderze innych wartości musisz zmienić wartości rozmiaru tekstu.

Uwaga: jak wskazał @espinchi, małe, normalne, duże i xlarge zostały wycofane od wersji Androida 3.2 na rzecz następujących:

Deklarowanie układów tabletu dla systemu Android 3.2

W przypadku pierwszej generacji tabletów z systemem Android 3.0 właściwym sposobem zadeklarowania układów tabletów było umieszczenie ich w katalogu z kwalifikatorem konfiguracji xlarge (na przykład res / layout-xlarge /). Aby dostosować się do innych typów tabletów i rozmiarów ekranów - w szczególności tabletów 7-calowych - Android 3.2 wprowadza nowy sposób określania zasobów dla bardziej dyskretnych rozmiarów ekranów. Nowa technika opiera się na ilości miejsca wymaganego przez układ (np. 600 dp szerokości), zamiast próbować dopasować układ do uogólnionych grup rozmiarów (takich jak duże lub bardzo duże).

Powodem, dla którego projektowanie tabletów 7-calowych jest trudne w przypadku korzystania z uogólnionych grup rozmiarów, jest fakt, że tablet 7-calowy należy technicznie do tej samej grupy co telefon 5-calowy (duża grupa). Chociaż te dwa urządzenia są pozornie blisko siebie , ilość miejsca na interfejs użytkownika aplikacji jest znacząco różna, podobnie jak styl interakcji użytkownika. Dlatego ekrany o przekątnej 7 i 5 cali nie powinny zawsze mieć tego samego układu. Aby umożliwić Ci zapewnienie różnych układów dwa rodzaje ekranów, system Android umożliwia teraz określanie zasobów układu w oparciu o szerokość i / lub wysokość, które są faktycznie dostępne dla układu aplikacji, określone w jednostkach dp.

Na przykład po zaprojektowaniu układu, którego chcesz używać dla urządzeń typu tablet, możesz stwierdzić, że układ przestaje działać dobrze, gdy szerokość ekranu jest mniejsza niż 600 dp. W ten sposób ten próg staje się minimalnym rozmiarem wymaganym dla układu tabletu. W związku z tym można teraz określić, że te zasoby układu powinny być używane tylko wtedy, gdy dla interfejsu użytkownika aplikacji jest dostępne co najmniej 600 dp szerokości.

Powinieneś albo wybrać szerokość i zaprojektować ją jako rozmiar minimalny, albo przetestować najmniejszą szerokość obsługiwaną przez twój układ po jego ukończeniu.

Uwaga: Pamiętaj, że wszystkie liczby używane w tych nowych interfejsach API rozmiaru są niezależnymi od gęstości wartościami pikseli (dp), a wymiary układu powinny być zawsze definiowane za pomocą jednostek dp, ponieważ zależy Ci na ilości miejsca na ekranie dostępnej po systemie uwzględnia gęstość ekranu (w przeciwieństwie do używania rozdzielczości surowych pikseli). Aby uzyskać więcej informacji na temat pikseli niezależnych od gęstości, przeczytaj Terminy i pojęcia we wcześniejszej części tego dokumentu. Korzystanie z nowych kwalifikatorów rozmiaru

Różne konfiguracje zasobów, które możesz określić na podstawie miejsca dostępnego dla twojego układu, podsumowano w tabeli 2. Te nowe kwalifikatory zapewniają większą kontrolę nad określonymi rozmiarami ekranu obsługiwanymi przez aplikację w porównaniu z tradycyjnymi grupami rozmiarów ekranu (mały, normalny, duży i bardzo duży).

Uwaga: Rozmiary określone za pomocą tych kwalifikatorów nie są rzeczywistymi rozmiarami ekranu. Rozmiary dotyczą raczej szerokości lub wysokości w jednostkach dp, które są dostępne w oknie Twojej aktywności. System Android może wykorzystywać część ekranu dla interfejsu użytkownika systemu (na przykład pasek systemowy u dołu ekranu lub pasek stanu u góry), więc część ekranu może nie być dostępna dla Twojego układu. Dlatego deklarowane rozmiary powinny w szczególności dotyczyć rozmiarów potrzebnych do wykonania czynności - system uwzględnia wszelkie miejsce używane przez interfejs użytkownika systemu podczas deklarowania, ile miejsca zapewnia układ. Uważaj również, że pasek akcji jest uważany za część przestrzeni okna aplikacji, chociaż Twój układ go nie deklaruje, więc zmniejsza przestrzeń dostępną dla układu i musisz to uwzględnić w swoim projekcie.

Tabela 2. Nowe kwalifikatory konfiguracji dla rozmiaru ekranu (wprowadzone w Androidzie 3.2). Konfiguracja ekranu Wartości kwalifikatorów Opis smallestWidth swdp

Przykłady: sw600dp sw720dp

Podstawowy rozmiar ekranu, na co wskazuje najkrótszy wymiar dostępnego obszaru ekranu. Mówiąc dokładniej, najmniejsza szerokość urządzenia to najkrótsza z dostępnej wysokości i szerokości ekranu (możesz też myśleć o niej jako o „najmniejszej możliwej szerokości” ekranu). Możesz użyć tego kwalifikatora, aby upewnić się, że niezależnie od bieżącej orientacji ekranu aplikacja ma co najmniej dps szerokości dostępnej dla jej interfejsu użytkownika.

Na przykład, jeśli twój układ wymaga, aby jego najmniejszy wymiar obszaru ekranu zawsze wynosił co najmniej 600 dp, możesz użyć tego kwalifikatora do utworzenia zasobów układu, res / layout-sw600dp /. System użyje tych zasobów tylko wtedy, gdy najmniejszy dostępny rozmiar ekranu to co najmniej 600 dp, niezależnie od tego, czy strona 600 dp jest wysokością czy szerokością postrzeganą przez użytkownika. Najmniejsza szerokość to stały rozmiar ekranu charakterystyczny dla urządzenia; najmniejsza szerokość urządzenia nie zmienia się, gdy zmienia się orientacja ekranu.

Najmniejsza szerokość urządzenia uwzględnia dekoracje ekranu i interfejs użytkownika systemu. Na przykład, jeśli urządzenie ma pewne trwałe elementy interfejsu użytkownika na ekranie, które uwzględniają przestrzeń wzdłuż osi najmniejszej szerokości, system zadeklaruje najmniejszą szerokość jako mniejszą niż rzeczywisty rozmiar ekranu, ponieważ są to piksele ekranu niedostępne dla interfejsu użytkownika.

Jest to alternatywa dla uogólnionych kwalifikatorów rozmiaru ekranu (small, normal, large, xlarge), która umożliwia zdefiniowanie dyskretnej liczby dla efektywnego rozmiaru dostępnego dla interfejsu użytkownika. Użycie funkcji najmniejsza szerokość do określenia ogólnego rozmiaru ekranu jest przydatne, ponieważ szerokość jest często czynnikiem napędzającym projektowanie układu. Interfejs użytkownika często przewija się w pionie, ale ma dość twarde ograniczenia dotyczące minimalnej wymaganej przestrzeni w poziomie. Dostępna szerokość jest również kluczowym czynnikiem przy określaniu, czy zastosować układ z jednym panelem w przypadku telefonów, czy układ z wieloma panelami w przypadku tabletów. Dlatego prawdopodobnie najbardziej zależy Ci na tym, jaka najmniejsza możliwa szerokość będzie na każdym urządzeniu. Dostępna szerokość ekranu wdp

Przykłady: w720dp w1024dp

Określa minimalną dostępną szerokość w jednostkach dp, przy której zasoby powinny być używane - zdefiniowaną przez wartość. Odpowiednia dla systemu wartość szerokości zmienia się, gdy orientacja ekranu zmienia się z poziomej na pionową, aby odzwierciedlić bieżącą rzeczywistą szerokość dostępną dla interfejsu użytkownika.

Jest to często przydatne do określenia, czy użyć układu z wieloma panelami, ponieważ nawet na tablecie często nie chcesz mieć tego samego układu z wieloma panelami w orientacji pionowej, jak w przypadku poziomego. W związku z tym można użyć tego do określenia minimalnej szerokości wymaganej dla układu, zamiast używać razem kwalifikatorów rozmiaru ekranu i orientacji. Dostępna wysokość ekranu hdp

Przykłady: h720dp h1024dp itp.

Określa minimalną wysokość ekranu w jednostkach dp, przy której zasoby powinny być używane - zdefiniowaną przez wartość. Odpowiednia dla systemu wartość wysokości zmienia się, gdy orientacja ekranu zmienia się z poziomej na pionową, aby odzwierciedlić bieżącą rzeczywistą wysokość dostępną dla interfejsu użytkownika.

Użycie tego do zdefiniowania wysokości wymaganej przez układ jest przydatne w taki sam sposób, jak wdp do definiowania wymaganej szerokości, zamiast używania zarówno rozmiaru ekranu, jak i kwalifikatorów orientacji. Jednak większość aplikacji nie potrzebuje tego kwalifikatora, biorąc pod uwagę, że interfejsy użytkownika często przewijają się w pionie, a zatem są bardziej elastyczne w zależności od dostępnej wysokości, podczas gdy szerokość jest bardziej sztywna.

Chociaż korzystanie z tych kwalifikatorów może wydawać się bardziej skomplikowane niż używanie grup rozmiarów ekranu, w rzeczywistości powinno być prostsze po określeniu wymagań dotyczących interfejsu użytkownika. Podczas projektowania interfejsu użytkownika najważniejszą rzeczą, na której prawdopodobnie zależy, jest rzeczywisty rozmiar, przy którym aplikacja przełącza się między interfejsem w stylu telefonu a interfejsem w stylu tabletu, który używa wielu paneli. Dokładny punkt tego przełącznika będzie zależał od konkretnego projektu - być może potrzebujesz szerokości 720 dp dla układu tabletu, być może wystarczy 600 dp, 480 dp lub pewna liczba między nimi. Korzystając z tych kwalifikatorów w tabeli 2, masz kontrolę nad dokładnym rozmiarem, w jakim zmienia się układ.

Aby uzyskać więcej informacji na temat kwalifikatorów konfiguracji rozmiaru, zobacz dokument Providing Resources. Przykłady konfiguracji

Aby ułatwić kierowanie niektórych projektów na różne typy urządzeń, poniżej podajemy kilka danych o typowych szerokościach ekranu:

320dp: a typical phone screen (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).
480dp: a tweener tablet like the Streak (480x800 mdpi).
600dp: a 7” tablet (600x1024 mdpi).
720dp: a 10” tablet (720x1280 mdpi, 800x1280 mdpi, etc).

Korzystając z kwalifikatorów rozmiaru z tabeli 2, aplikacja może przełączać się między różnymi zasobami układu dla telefonów i tabletów, używając dowolnej liczby dla szerokości i / lub wysokości. Na przykład, jeśli 600 dp to najmniejsza dostępna szerokość obsługiwana przez układ tabletu, możesz podać te dwa zestawy układów:

res / layout / main_activity.xml # Dla telefonów res / layout-sw600dp / main_activity.xml # Dla tabletów

W takim przypadku najmniejsza szerokość dostępnego miejsca na ekranie musi wynosić 600 dp, aby można było zastosować układ tabletu.

W innych przypadkach, w których chcesz bardziej dostosować swój interfejs użytkownika, aby rozróżnić rozmiary, takie jak tablety 7 ”i 10”, możesz zdefiniować dodatkowe układy o najmniejszej szerokości:

res / layout / main_activity.xml # Dla telefonów (mniejszych niż 600dp dostępnej szerokości) res / layout-sw600dp / main_activity.xml # Dla tabletów 7 ”(600dp szerokości i większych) res / layout-sw720dp / main_activity.xml

Na 10-calowe tablety (720dp szerokości i większe)

Należy zauważyć, że poprzednie dwa zestawy przykładowych zasobów używają kwalifikatora „najmniejszej szerokości”, swdp, który określa najmniejszą z dwóch stron ekranu, niezależnie od bieżącej orientacji urządzenia. W związku z tym użycie swdp jest prostym sposobem określenia całkowitego rozmiaru ekranu dostępnego dla twojego układu poprzez ignorowanie orientacji ekranu.

Jednak w niektórych przypadkach to, co może być ważne dla twojego układu, to dokładna wielkość aktualnie dostępnej szerokości lub wysokości. Na przykład, jeśli masz układ z dwoma panelami z dwoma fragmentami obok siebie, możesz go użyć, gdy ekran ma co najmniej 600 dp szerokości, niezależnie od tego, czy urządzenie jest w orientacji poziomej czy pionowej. W takim przypadku Twoje zasoby mogą wyglądać następująco:

res / layout / main_activity.xml # Dla telefonów (mniejszych niż 600dp dostępnej szerokości) res / layout-w600dp / main_activity.xml # Multi-panel (dowolny ekran z dostępną szerokością 600dp lub większą)

Zwróć uwagę, że drugi zestaw używa kwalifikatora „dostępnej szerokości”, wdp. W ten sposób jedno urządzenie może faktycznie korzystać z obu układów, w zależności od orientacji ekranu (jeśli dostępna szerokość wynosi co najmniej 600 dp w jednej orientacji i mniej niż 600 dp w drugiej orientacji).

Jeśli zależy Ci na dostępnej wysokości, możesz zrobić to samo, używając kwalifikatora hdp. Lub nawet połącz kwalifikatory wdp i hdp, jeśli chcesz być naprawdę konkretny.

Myślę, że jest już za późno, aby odpowiedzieć w tym wątku. Ale chciałbym podzielić się moim pomysłem lub sposobem rozwiązania problemu z rozmiarem tekstu na urządzeniach o różnej rozdzielczości. Wiele witryn programistów Androida sugeruje, że musimy użyć jednostki sp dla rozmiaru tekstu, która będzie obsługiwać rozmiar tekstu dla urządzeń o różnej rozdzielczości. Ale zawsze nie jestem w stanie osiągnąć pożądanego rezultatu. Znalazłem więc jedno rozwiązanie, którego używam z moich ostatnich 4-5 projektów i działa dobrze. Zgodnie z moją sugestią musisz ustawić rozmiar tekstu dla każdego urządzenia rozdzielczości, co jest trochę żmudną pracą, ale spełni twoje wymagania. Każdy programista musi słuchać o stosunku 4: 6: 8: 12 (odpowiednio: h: xh: xxh: xxxh) . Teraz w folderze res projektu musisz utworzyć 4 foldery z plikiem dimens np

1. res / values-hdpi / dimens.xml
2. res / values-xhdpi / dimens.xml
3. res / values-xxhdpi / dimens.xml
4. res / values-xxxhdpi / dimens.xml

Teraz w pliku dimens.xml musisz umieścić rozmiary tekstu. Pokazuję kod dla values-hdpi , podobnie musisz umieścić kod dla innego pliku wartości rozdzielczości / dimens.xml.

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">4px</dimen>
</resources>

W przypadku innych rozdzielczości jest to xhdpi : 6px , xxhdpi : 8px , xxxhdpi : 12px . Oblicza się to ze stosunku (3: 4: 6: 8: 12), który napisałem powyżej. Omówmy inny przykład rozmiaru tekstu z powyższym współczynnikiem. Jeśli chcesz mieć tekst o rozmiarze 12 pikseli w HDpi, to w innej rozdzielczości będzie

1. hdpi: 12px
2. xhdpi: 18 pikseli
3. xxhdpi: 24px
4. xxxhdpi: 36px

Jest to proste rozwiązanie umożliwiające zaimplementowanie wymaganego rozmiaru tekstu dla wszystkich rozdzielczości. Nie rozważam tutaj urządzeń o rozdzielczości wartości-mdpi . Jeśli ktoś chce uwzględnić rozmiar tekstu dla tej rozdzielczości, to stosunek jest jak 3: 4: 6: 8: 12 . W przypadku jakichkolwiek pytań proszę o informację. Mam nadzieję, że ci to pomoże.

Czasami lepiej mieć tylko trzy opcje

 style="@android:style/TextAppearance.Small"

Użyj małego i dużego, aby odróżnić normalny rozmiar ekranu.

<TextView
            android:id="@+id/TextViewTopBarTitle"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            style="@android:style/TextAppearance.Small"/>

Normalnie nie musisz niczego określać.

<TextView
            android:id="@+id/TextViewTopBarTitle"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>

Dzięki temu można uniknąć testowania i określania wymiarów dla różnych rozmiarów ekranu.

Zrobiłem to samo przez wymiar i namalowałem coś takiego (z dp, ale tylko dla tekstu i drawText ())

XML:

   <dimen name="text_size">30sp</dimen>

Kod:

   Paint p =new Paint();
       p.setTextSize(getResources().getDimension(R.dimen.text_Size));

Każdy może skorzystać z poniższej biblioteki Androida, która jest najłatwiejszym sposobem na dostosowanie rozmiarów tekstu do prawie wszystkich ekranów urządzeń. W rzeczywistości opracowano go na podstawie nowych kwalifikatorów konfiguracji Androida dla rozmiaru ekranu (wprowadzonych w Androidzie 3.2) SmallestWidth swdp.

https://github.com/intuit/sdp

Jeśli masz API 26, możesz rozważyć użycie autoSizeTextType :

<Button
  app:autoSizeTextType="uniform" />

Ustawienie domyślne umożliwia automatyczne skalowanie rozmiaru TextView równomiernie na osi poziomej i pionowej.

https://developer.android.com/guide/topics/ui/look-and-feel/autosizing-textview

Myślę, że możesz to zarchiwizować, dodając wiele zasobów układu dla każdego rozmiaru ekranu, przykład:

res/layout/my_layout.xml             // layout for normal screen size ("default")
res/layout-small/my_layout.xml       // layout for small screen size with small text
res/layout-large/my_layout.xml       // layout for large screen size with larger text
res/layout-xlarge/my_layout.xml      // layout for extra large screen size with even larger text
res/layout-xlarge-land/my_layout.xml // layout for extra large in landscape orientation

Źródła: 1. http://developer.android.com/guide/practices/screens_support.html

Aby ujednolicić wszystkie ekrany, aby wyświetlały te same rozmiary elementów, w tym rozmiar czcionki: - Zaprojektuj interfejs użytkownika na jednym rozmiarze ekranu z dowolnymi rozmiarami, które uznasz za odpowiednie podczas projektowania, tj. Rozmiar czcionki TextView to 14 dp przy domyślnym rozmiarze ekranu 4'6 cali.

• Oblicz programowo fizyczny rozmiar ekranu innych telefonów, tj. 5'2 cale innych telefonów / ekranów.

• Użyj wzoru, aby obliczyć procentową różnicę między 2 ekranami. tj. jaka jest% różnica między 4'6 a 5'2.

• Oblicz różnicę pikseli między dwoma widokami TextView na podstawie powyższego wzoru.

• Uzyskaj rzeczywisty rozmiar (w pikselach) rozmiaru czcionki TextView i zastosuj różnicę pikseli (obliczoną wcześniej) do domyślnego rozmiaru czcionki.

W ten sposób możesz zastosować dynamiczny współczynnik proporcji do wszystkich rozmiarów ekranu, a wynik jest świetny. Będziesz mieć identyczny układ i rozmiary na każdym ekranie.

Na początku może to być trochę trudne, ale całkowicie osiąga cel, gdy wymyślisz formułę. Dzięki tej metodzie nie musisz tworzyć wielu układów tylko po to, aby pasowały do ​​różnych rozmiarów ekranu.

Możesz także użyć weightSumi layout_weightproperty, aby dostosować inny ekran.

W tym celu musisz zrobić android:layout_width= 0dp i android:layout_width= (cokolwiek chcesz);

Jak wspomniał @espinchi z 3.2 (poziom API 13), grupy rozmiarów są przestarzałe. Zakresy rozmiarów ekranu są preferowanym podejściem w przyszłości.

Nie koduj rozmiarów na stałe.

Aby zwiększyć elastyczność i nowe rozdzielczości ekranu - najlepszą praktyką jest umieszczenie fikcyjnego TextView w układzie, aby uzyskać textSize:

<TextView
        android:id="@+id/dummyTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="gone"
        android:text="TextView" />

A w swoim kodzie na przykład:

TextView testTextView = (TextView) rootView.findViewById(R.id.dummyTextView);
float textSize = testTextView.getTextSize();

Zachowaj textSizejako odniesienie, do którego możesz dodać stały lub procentowy rozmiar (przez obliczenie).