Android
Zasoby

Przetłumacz ciąg

Ciągi można internacjonalizować, definiując inny ciąg str.xml dla każdego obsługiwanego języka.

Dodajesz nowy język, tworząc nowy katalog wartości z kodem języka ISO jako sufiksem. Na przykład po dodaniu zestawu niemieckiego struktura może wyglądać następująco:

Gdy system szuka żądanego ciągu znaków, najpierw sprawdza plik XML specyficzny dla języka. Jeśli nie zostanie znaleziony, zwracana jest wartość z domyślnego pliku strings.xml. Klucz pozostaje taki sam dla każdego języka i zmienia się tylko wartość.

Przykładowa zawartość:

/res/values/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">HelloWorld</string>
    <string name="hello_world">Hello World!</string>
</resources>

/res/values-fr/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello_world">Bonjour tout le monde !!!</string>
</resources>

Zdefiniuj ciągi

Ciągi są zwykle przechowywane w pliku zasobów strings.xml . Są one definiowane za pomocą elementu XML <string> .

Celem pliku strings.xml jest umożliwienie internacjonalizacji. Możesz zdefiniować strings.xml dla każdego kodu iso języka. Tak więc, gdy system szuka ciągu „nazwa_aplikacji”, najpierw sprawdza plik xml odpowiadający bieżącemu językowi, a jeśli go nie znaleziono, szuka wpisu w domyślnym pliku strings.xml. Oznacza to, że możesz wybrać lokalizację tylko niektórych ciągów, a innych nie.

/res/values/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Hello World App</string>
    <string name="hello_world">Hello World!</string>
</resources>

Po zdefiniowaniu ciągu w pliku zasobów XML może być używany przez inne części aplikacji.

Pliki projektu XML aplikacji mogą korzystać z elementu <string> , odwołując się do @string/string_name . Na przykład plik manifestu aplikacji (/manifests/AndroidManifest.xml) zawiera domyślnie następujący wiersz w Android Studio:

android:label="@string/app_name"

Mówi to systemowi Android, aby szukał zasobu <string> nazwie „nazwa_aplikacji”, który mógłby być użyty jako nazwa aplikacji po jej zainstalowaniu lub wyświetleniu w programie uruchamiającym.

Innym razem, gdy użyjesz zasobu <string> z pliku XML w systemie Android, będzie to plik układu. Na przykład poniższe przedstawia TextView, który wyświetla zdefiniowany wcześniej ciąg hello_world :

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

Możesz również uzyskać dostęp do <string> zasobów z części Java aplikacji. Aby przywołać z góry ten sam ciąg hello_world w klasie Activity, użyj:

String helloWorld = getString(R.string.hello_world);

Zdefiniuj tablicę ciągów

Aby zdefiniować tablicę ciągów, zapisz w pliku zasobów

res / wartości / nazwa_pliku.xml

<string-array name="string_array_name">
    <item>text_string</item>
    <item>@string/string_id</item>
</string-array>

na przykład

res / wartości / tablice.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="string_array_example">
        <item>@string/app_name</item>
        <item>@string/hello_world</item>
    </string-array>
</resources>

i używaj go z Java

String[] strings = getResources().getStringArray(R.array.string_array_example;
Log.i("TAG",Arrays.toString(strings)));

Wynik

I/TAG: [HelloWorld, Hello World!]

Zdefiniuj wymiary

Wymiary są zwykle przechowywane w nazwach plików zasobów dimens.xml . Są one definiowane za pomocą elementu <dimen> .

res / wartości / dimens.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="small_padding">5dp</dimen>
    <dimen name="medium_padding">10dp</dimen>
    <dimen name="large_padding">20dp</dimen>

    <dimen name="small_font">14sp</dimen>
    <dimen name="medium_font">16sp</dimen>
    <dimen name="large_font">20sp</dimen>
</resources> 

Możesz użyć różnych jednostek:

• sp: piksele niezależne od skali. Dla czcionek.
• dp: piksele niezależne od gęstości. Za wszystko inne.
• pt: Punkty
• px: Piksele
• mm: Milimetry
• im: Cale

Do wymiarów można teraz odwoływać się w formacie XML za pomocą składni @dimen/name_of_the_dimension .

Na przykład:

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/large_padding">
</RelativeLayout>

Zdefiniuj liczby całkowite

Liczby całkowite są zwykle przechowywane w pliku zasobów o nazwie integers.xml , ale nazwę pliku można wybrać dowolnie. Każda liczba całkowita jest definiowana za pomocą elementu <integer> , jak pokazano w następującym pliku:

res / wartości / integers.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer name="max">100</integer>
</resources> 

Do @integer/name_of_the_integer całkowitych można teraz odwoływać się w formacie XML za pomocą składni @integer/name_of_the_integer , jak pokazano w poniższym przykładzie:

<ProgressBar
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:max="@integer/max"/>

Zdefiniuj tablicę liczb całkowitych

Aby zdefiniować tablicę liczb całkowitych, zapisz w pliku zasobów

res / wartości / nazwa_pliku.xml

<integer-array name="integer_array_name">
    <item>integer_value</item>
    <item>@integer/integer_id</item>
</integer-array>

na przykład

res / wartości / tablice.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer-array name="fibo">
        <item>@integer/zero</item>
        <item>@integer/one</item>
        <item>@integer/one</item>
        <item>@integer/two</item>
        <item>@integer/three</item>
        <item>@integer/five</item>
    </integer-array>
</resources>

i używaj go z Java

int[] values = getResources().getIntArray(R.array.fibo);
Log.i("TAG",Arrays.toString(values)));

Wynik

I/TAG: [0, 1, 1, 2, 3, 5]

Określ kolory

Kolory są zwykle przechowywane w pliku zasobów o nazwie colors.xml w colors.xml /res/values/ .

Są zdefiniowane przez elementy <color> :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#3F51B5</color>
    <color name="colorPrimaryDark">#303F9F</color>
    <color name="colorAccent">#FF4081</color>

    <color name="blackOverlay">#66000000</color>
</resources>

Kolory są reprezentowane przez szesnastkowe wartości kolorów dla każdego kanału kolorów (0 - FF) w jednym z formatów:

• #RGB
• #ARGB
• #RRGGBB
• #AARRGGBB

Legenda

• A - kanał alfa - wartość 0 jest w pełni przezroczysta, wartość FF jest nieprzezroczysta
• R - czerwony kanał
• G - zielony kanał
• B - niebieski kanał

Zdefiniowane kolory mogą być używane w XML z następującą składnią @color/name_of_the_color

Na przykład:

<RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/blackOverlay">

Używanie kolorów w kodzie

Te przykłady zakładają, this jest to odwołanie do działania. Zamiast niego można również użyć odniesienia kontekstu.

int color = ContextCompat.getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

int color = this.getResources().getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

W powyższej deklaracji colorPrimary , colorPrimaryDark i colorAccent są używane do definiowania kolorów projektowania materiałów, które będą używane podczas definiowania niestandardowego motywu Androida w styles.xml . Są one automatycznie dodawane po utworzeniu nowego projektu w Android Studio.

Zdobywanie zasobów bez „przestarzałych” ostrzeżeń

Używając Android API 23 lub nowszego, bardzo często można zaobserwować taką sytuację:

Sytuacja ta jest spowodowana zmianami strukturalnymi interfejsu API Androida w zakresie pozyskiwania zasobów.
Teraz funkcja:

public int getColor(@ColorRes int id, @Nullable Theme theme) throws NotFoundException    

należy użyć. Ale biblioteka android.support.v4 ma inne rozwiązanie.

Dodaj następującą zależność do pliku build.gradle :

com.android.support:support-v4:24.0.0

Następnie dostępne są wszystkie metody z biblioteki wsparcia:

ContextCompat.getColor(context, R.color.colorPrimaryDark);
ContextCompat.getDrawable(context, R.drawable.btn_check);
ContextCompat.getColorStateList(context, R.color.colorPrimary);
DrawableCompat.setTint(drawable);
ContextCompat.getColor(context,R.color.colorPrimaryDark));

Ponadto można zastosować więcej metod z biblioteki wsparcia:

ViewCompat.setElevation(textView, 1F);
ViewCompat.animate(textView);
TextViewCompat.setTextAppearance(textView, R.style.AppThemeTextStyle);
...

Zdefiniuj zasób menu i użyj go wewnątrz działania / fragmentu

Zdefiniuj menu w res / menu

<?xml version="1.0" encoding="utf-8"?>
<menu
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item
        android:id="@+id/first_item_id"
        android:orderInCategory="100"
        android:title="@string/first_item_string"
        android:icon="@drawable/first_item_icon"
        app:showAsAction="ifRoom"/>

    <item
        android:id="@+id/second_item_id"
        android:orderInCategory="110"
        android:title="@string/second_item_string"
        android:icon="@drawable/second_item_icon"
        app:showAsAction="ifRoom"/>

</menu>

Aby uzyskać więcej opcji konfiguracji, patrz: Zasób menu

Activity wewnętrzna:

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    ///Override defining menu resource
    inflater.inflate(R.menu.menu_resource_id, menu);
    super.onCreateOptionsMenu(menu, inflater);
}

@Override
public void onPrepareOptionsMenu(Menu menu) {
    //Override for preparing items (setting visibility, change text, change icon...)
    super.onPrepareOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    //Override it for handling items
    int menuItemId = item.getItemId();
    switch (menuItemId) {
        case: R.id.first_item_id
             return true; //return true, if is handled
    }
    return super.onOptionsItemSelected(item);
}

Aby wywołać powyższe metody podczas wyświetlania widoku, wywołaj getActivity().invalidateOptionsMenu();

Wewnątrz Fragment potrzebne jest dodatkowe połączenie:

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    setHasOptionsMenu(true);
    super.onCreateView(inflater, container, savedInstanceState);
}

Formatowanie ciągów w strings.xml

Definiowanie ciągów w pliku strings.xml pozwala również na formatowanie ciągów. Jedynym zastrzeżeniem jest to, że ciąg będzie musiał być traktowany w kodzie jak poniżej, w porównaniu do zwykłego dołączenia go do układu.

<string name="welcome_trainer">Hello Pokémon Trainer, %1$s! You have caught %2$d Pokémon.</string>

String welcomePokemonTrainerText = getString(R.string.welcome_trainer, tranerName, pokemonCount);

W powyższym przykładzie
% 1 $ s
„%” oddziela się od normalnych znaków,
„1” oznacza pierwszy parametr,
„$” służy jako separator między numerem parametru a typem,
„s” oznacza typ ciągu („d” jest używane jako liczba całkowita)

Zauważ, że getString() jest metodą Context lub Resources , tzn. Możesz użyć jej bezpośrednio w instancji Activity , albo możesz użyć odpowiednio getActivity().getString() lub getContext().getString() .

Zdefiniuj listę stanów kolorów

Listy stanów kolorów mogą być używane jako kolory, ale zmieniają się w zależności od stanu widoku, w którym są używane.

Aby go zdefiniować, utwórz plik zasobów w res/color/foo.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:color="#888888" android:state_enabled="false"/>
    <item android:color="@color/lightGray" android:state_selected="false"/>
    <item android:color="@android:color/white" />
</selector>

Elementy są oceniane w kolejności, w jakiej zostały zdefiniowane, i używany jest pierwszy element, którego określone stany są zgodne z bieżącym stanem widoku. Dobrą praktyką jest więc określenie catch-all na końcu, bez określonych selektorów stanu.

Każdy element może używać literału koloru lub odwoływać się do koloru zdefiniowanego gdzie indziej.

Zdefiniuj formy liczby mnogiej

Aby rozróżnić ciągi liczby mnogiej i pojedynczej, możesz zdefiniować liczbę mnogą w pliku strings.xml i wypisać różne ilości, jak pokazano w poniższym przykładzie:

<?xml version="1.0" encoding="utf-8"?>
<resources>  
    <plurals name="hello_people">
        <item quantity="one">Hello to %d person</item>
        <item quantity="other">Hello to %d people</item>
    </plurals>
</resources>

Dostęp do tej definicji można uzyskać z kodu Java za pomocą metody getQuantityString() klasy Resources , jak pokazano w poniższym przykładzie:

getResources().getQuantityString(R.plurals.hello_people, 3, 3);

Tutaj pierwszym parametrem R.plurals.hello_people jest nazwa zasobu. Drugi parametr ( 3 w tym przykładzie) służy do wybrania prawidłowego ciągu quantity . Trzeci parametr (w tym przykładzie również 3 ) to argument formatu, który zostanie użyty do podstawienia specyfikatora formatu %d .

Możliwe wartości ilościowe (wymienione w kolejności alfabetycznej) to:

few
many
one
other
two
zero

Należy zauważyć, że nie wszystkie ustawienia regionalne obsługują każdy nominał quantity . Na przykład język chiński nie ma pojęcia one elementu. Angielski nie ma zero pozycji, ponieważ gramatycznie jest taki sam jak other . Nieobsługiwane przypadki quantity zostaną oznaczone przez IDE jako ostrzeżenia Lint, ale nie spowodują błędów komplikacji, jeśli zostaną użyte.

Importuj tablicę obiektów zdefiniowanych w zasobach

Są przypadki, w których niestandardowe obiekty muszą zostać utworzone i zdefiniowane w zasobach aplikacji. Takie obiekty mogą składać się z prostych typów Java , na przykład Integer , Float , String .

Oto przykład importowania obiektu zdefiniowanego w zasobach aplikacji. Category obiektu obejmuje 3 właściwości kategorii:

• ID
• Kolor
• Nazwa

Ten POJO ma swój odpowiednik w categories.xml pliku, gdzie każda tablica ma takie same właściwości zdefiniowane dla każdej kategorii.

1. Utwórz model dla swojego obiektu:

public class Category {
    private Type id;
    private @ColorRes int color;
    private @StringRes String name;

    public Category getId() {
        return id;
    }

    public void setId(Category id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public enum Type{
        REGISTRATION,
        TO_ACCEPT,
        TO_COMPLETE,
        TO_VERIFY,
        CLOSED
    }
}

2. Utwórz plik w folderze res/values :

categories.xml

3. Skomponuj każdy model składający się z zasobów:

<array name="no_action">
    <item>0</item>
    <item>@android:color/transparent</item>
    <item>@string/statusRegistration</item>
</array>
<array name="to_accept">
    <item>1</item>
    <item>@color/light_gray</item>
    <item>@string/acceptance</item>
</array>
<array name="opened">
    <item>2</item>
    <item>@color/material_green_500</item>
    <item>@string/open</item>
</array>
<array name="to_verify">
    <item>3</item>
    <item>@color/material_gray_800</item>
    <item>@string/verification</item>
</array>
<array name="to_close">
    <item>4</item>
    <item>@android:color/black</item>
    <item>@string/closed</item>
</array>

4. Zdefiniuj tablicę w pliku zasobów:

   <array name="categories">
       <item>@array/no_action</item>
       <item>@array/to_accept</item>
       <item>@array/opened</item>
       <item>@array/to_verify</item>
       <item>@array/to_close</item>
   </array>
   

5. Utwórz funkcję, aby je zaimportować:

   @NonNull
   public List<Category> getCategories(@NonNull Context context) {
   final int DEFAULT_VALUE = 0;
   final int ID_INDEX = 0;
   final int COLOR_INDEX = 1;
   final int LABEL_INDEX = 2;
   
   if (context == null) {
       return Collections.emptyList();
   }
   // Get the array of objects from the `tasks_categories` array
   TypedArray statuses = context.getResources().obtainTypedArray(R.array.categories);
   if (statuses == null) {
       return Collections.emptyList();
   }
   List<Category> categoryList = new ArrayList<>();
   for (int i = 0; i < statuses.length(); i++) {
       int statusId = statuses.getResourceId(i, DEFAULT_VALUE);
       // Get the properties of one object
       TypedArray rawStatus = context.getResources().obtainTypedArray(statusId);
   
       Category category = new Category();
   
       int id = rawStatus.getInteger(ID_INDEX, DEFAULT_VALUE);
       Category.Type categoryId;
       //The ID's should maintain the order with `Category.Type`
       switch (id) { 
           case 0:
               categoryId = Category.Type.REGISTRATION;
               break;
           case 1:
               categoryId = Category.Type.TO_ACCEPT;
               break;
           case 2:
               categoryId = Category.Type.TO_COMPLETE;
               break;
           case 3:
               categoryId = Category.Type.TO_VERIFY;
               break;
           case 4:
               categoryId  = Category.Type.CLOSED;
               break;
           default:
               categoryId = Category.Type.REGISTRATION;
               break;
       }
       category.setId(categoryId);
   
       category.setColor(rawStatus.getResourceId(COLOR_INDEX, DEFAULT_VALUE));
   
       int labelId = rawStatus.getResourceId(LABEL_INDEX, DEFAULT_VALUE);
       category.setName(getString(context.getResources(), labelId));
   
       categoryList.add(taskCategory);
   }
   return taskCategoryList;
   }
   

9 łatek

9 Łaty są rozciągliwymi obrazami, w których obszary, które można rozciągnąć, są oznaczone czarnymi znacznikami na przezroczystej ramce.

Jest to świetny poradnik tutaj .
Pomimo tego, że jest tak stary, wciąż jest tak cenny i pomógł wielu z nas dogłębnie zrozumieć sprzęt z 9 łatkami.

Niestety, ostatnio ta strona została odłożona na jakiś czas (obecnie jest ponownie wyświetlana).

Stąd potrzeba posiadania fizycznej kopii tej strony dla programistów Androida na naszych niezawodnych serwerach.

Oto jest.

PROSTY PRZEWODNIK PO 9-PATCHOWYM SYSTEMIE NA ANDROIDA 18 maja 2011 r

Podczas pracy nad moją pierwszą aplikacją na Androida odkryłem, że 9-łatka (inaczej 9.png) jest myląca i źle udokumentowana. Po chwili w końcu zrozumiałem, jak to działa, i postanowiłem zebrać coś, co pomoże innym to rozgryźć.

Zasadniczo 9-łatka używa przezroczystości png, aby wykonać zaawansowaną formę 9-plasterka lub skali9. Linie pomocnicze są prostymi, 1-pikselowymi czarnymi liniami narysowanymi na krawędzi obrazu, które określają skalowanie i wypełnienie obrazu. Nazwij plik obrazu name.9.png, system Android rozpozna format 9.png i użyje czarnych prowadnic do skalowania i wypełniania map bitowych.

Oto podstawowa mapa przewodnika:

Jak widać, po każdej stronie obrazu znajdują się przewodniki. Prowadnice GÓRA i LEWO służą do skalowania obrazu (tj. 9-warstwowy), natomiast prowadnice PRAWO i DOLNIE określają obszar wypełnienia.

Czarne linie pomocnicze są odcięte / usunięte z obrazu - nie będą wyświetlane w aplikacji. Linie pomocnicze muszą mieć szerokość tylko jednego piksela, więc jeśli chcesz przycisk 48 × 48, twój png będzie w rzeczywistości 50 × 50. Wszystko grubsze niż jeden piksel pozostanie częścią obrazu. (Moje przykłady mają 4-pikselowe prowadnice dla lepszej widoczności. Naprawdę powinny one mieć tylko 1 piksel).

Twoje przewodniki muszą być jednolicie czarne (# 000000). Nawet niewielka różnica w kolorze (# 000001) lub alfa spowoduje, że zawiodą i rozciągną się normalnie. Ta awaria też nie będzie oczywista *, po cichu zawiedzie! Tak. Naprawdę. Teraz wiesz.

Należy również pamiętać, że pozostały obszar konturu jednego piksela musi być całkowicie przezroczysty. Obejmuje to cztery rogi obrazu - zawsze powinny być wyraźne. To może być większy problem, niż ci się wydaje. Na przykład, jeśli skalujesz obraz w Photoshopie, doda to wygładzone piksele, które mogą zawierać prawie niewidoczne piksele, które również spowodują jego awarię *. Jeśli musisz skalować w Photoshopie, użyj ustawienia Nearest Neighbor w menu rozwijanym Resample Image (na dole menu podręcznego Image Size), aby zachować ostre krawędzie na prowadnicach.

* (zaktualizowany 1/2012) To jest rzeczywiście „poprawka” w najnowszym zestawie programistów. Wcześniej przejawiałoby się to jako nagłe uszkodzenie wszystkich innych obrazów i zasobów, a nie faktycznie zepsuty obraz 9-krotny.

Prowadnice GÓRA i LEWO służą do definiowania skalowalnej części obrazu - LEWO dla wysokości skalowania, GÓRA dla szerokości skalowania. Wykorzystując przykładowy obraz przycisku, oznacza to, że przycisk może rozciągać się poziomo i pionowo w obrębie czarnej części, a wszystko inne, takie jak narożniki, pozostanie tego samego rozmiaru. Pozwala mieć przyciski, które można skalować do dowolnego rozmiaru i zachować jednolity wygląd.

Ważne jest, aby pamiętać, że 9-łatkowe obrazy nie skalują się w dół - tylko skalują w górę. Więc najlepiej zacząć od jak najmniejszego.

Możesz również pominąć fragmenty na środku linii skali. Na przykład, jeśli masz przycisk z ostrą błyszczącą krawędzią pośrodku, możesz pominąć kilka pikseli na środku LEWEGO przewodnika. Środkowa pozioma oś obrazu nie będzie się skalować, tylko części powyżej i poniżej, dzięki czemu twój ostry połysk nie zostanie wygładzony ani rozmazany.

Przewodniki po obszarach wypełnienia są opcjonalne i umożliwiają zdefiniowanie obszaru dla takich rzeczy, jak etykieta tekstowa. Wypełnienie określa, ile miejsca w obrazie ma miejsce na umieszczenie tekstu, ikony lub innych rzeczy. 9-łatka jest nie tylko dla przycisków, ale działa również na obrazy tła.

Powyższy przykład przycisku i etykiety jest przesadzony w celu wyjaśnienia idei wypełnienia - etykieta nie jest całkowicie dokładna. Szczerze mówiąc, nie doświadczyłem, jak Android robi etykiety wieloliniowe, ponieważ etykieta przycisku jest zwykle pojedynczym wierszem tekstu.

Na koniec, oto dobra demonstracja różnic między liniami skalowania i wypełnienia, na przykład układ liniowy z obrazem tła i całkowicie zaokrąglonymi bokami:

W tym przykładzie przewodnik LEFT nie jest używany, ale nadal musimy mieć przewodnik. Obraz w tle nie jest skalowany w pionie; po prostu skaluje się w poziomie (w oparciu o TOP przewodnik). Patrząc na prowadnice wypełnienia, prowadnice PRAWY i DOLNY rozciągają się poza miejsce, w którym stykają się z zakrzywionymi krawędziami obrazu. Pozwala mi to umieścić okrągłe guziki blisko krawędzi tła, aby uzyskać ciasny, dopasowany wygląd.

Więc to jest to. 9-łatka jest bardzo łatwa, gdy ją otrzymasz. Nie jest to idealny sposób na skalowanie, ale linie wypełnienia i wieloliniowe prowadnice skalowania oferują większą elastyczność niż tradycyjne 9-segmentowe i skalowanie9. Spróbuj, a szybko to rozwiążesz.

Poziom przezroczystości kolorów (alfa)

Wartości krycia szesnastkowego

    ------------------------------
   |   Alpha(%)  |   Hex Value    |
    ------------------------------
   |    100%     |      FF        |
   |     95%     |      F2        |
   |     90%     |      E6        |
   |     85%     |      D9        |
   |     80%     |      CC        |
   |     75%     |      BF        |
   |     70%     |      B3        |
   |     65%     |      A6        |
   |     60%     |      99        |
   |     55%     |      8C        |
   |     50%     |      80        |
   |     45%     |      73        |
   |     40%     |      66        |
   |     35%     |      59        |
   |     30%     |      4D        |
   |     25%     |      40        |
   |     20%     |      33        |
   |     15%     |      26        |
   |     10%     |      1A        |
   |      5%     |      0D        |
   |      0%     |      00        |
    ------------------------------   

Jeśli chcesz ustawić 45% na kolor czerwony.

<color name="red_with_alpha_45">#73FF0000</color> 

wartość szesnastkowa dla czerwonego - # FF0000

Możesz dodać 73 dla 45% krycia w prefiksie - # 73FF0000

Praca z plikiem strings.xml

Zasób ciągów zapewnia ciągi tekstowe dla aplikacji z opcjonalnym stylem i formatowaniem tekstu. Istnieją trzy rodzaje zasobów, które mogą dostarczyć twojej aplikacji ciągi znaków:

Strunowy

XML resource that provides a single string.

Składnia:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="string_name">text_string</string>
</resources>

Aby użyć tego ciągu w układzie:

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/string_name" />

Tablica ciągów

XML resource that provides an array of strings.

Składnia:

    <resources>
<string-array name="planets_array">
    <item>Mercury</item>
    <item>Venus</item>
    <item>Earth</item>
    <item>Mars</item>
</string-array>

Stosowanie

Resources res = getResources();
String[] planets = res.getStringArray(R.array.planets_array);

Ciągi ilości (liczba mnoga)

XML resource that carries different strings for pluralization. 

Składnia:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals
        name="plural_name">
        <item
            quantity=["zero" | "one" | "two" | "few" | "many" | "other"]
            >text_string</item>
    </plurals>
</resources>

Stosowanie:

int count = getNumberOfsongsAvailable();
Resources res = getResources();
String songsFound = res.getQuantityString(R.plurals.plural_name, count, count);