Android
Middelen

Vertaal een string

Strings kunnen worden geïnternationaliseerd door een andere strings.xml te definiëren voor elke taal die u ondersteunt.

U voegt een nieuwe taal toe door een nieuwe waardenmap te maken met de ISO-taalcode als achtervoegsel. Wanneer u bijvoorbeeld een Duitse set toevoegt, kan uw structuur er als volgt uitzien:

Wanneer het systeem de gevraagde tekenreeks zoekt, wordt eerst de taalspecifieke xml gecontroleerd. Als deze niet wordt gevonden, wordt de waarde van het standaardbestand strings.xml geretourneerd. De sleutel blijft hetzelfde voor elke taal en alleen de waarde verandert.

Voorbeeld inhoud:

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

Definieer tekenreeksen

strings.xml worden meestal opgeslagen in het bronbestand strings.xml . Ze worden gedefinieerd met behulp van een <string> XML-element.

Het doel van strings.xml is internationalisering mogelijk te maken. U kunt een strings.xml definiëren voor elke iso-code van de taal. Dus als het systeem naar de tekenreeks 'app_name' zoekt, controleert het eerst het xml-bestand dat overeenkomt met de huidige taal, en als het niet wordt gevonden, zoekt het naar het item in het standaard strings.xml-bestand. Dit betekent dat u ervoor kunt kiezen om slechts enkele van uw strings te lokaliseren, terwijl andere niet.

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

Als een string eenmaal is gedefinieerd in een XML-bronbestand, kan deze worden gebruikt door andere delen van de app.

De XML-projectbestanden van een app kunnen een <string> -element gebruiken door te verwijzen naar @string/string_name . Het manifestbestand (/manifests/AndroidManifest.xml) van een app bevat bijvoorbeeld standaard de volgende regel in Android Studio:

android:label="@string/app_name"

Dit vertelt android om te zoeken naar een <string> -bron met de naam "app_name" die moet worden gebruikt als de naam voor de app wanneer deze wordt geïnstalleerd of weergegeven in een opstartprogramma.

Een andere keer dat u een <string> -bron uit een XML-bestand in Android zou gebruiken, zou dit in een lay-outbestand zijn. Het volgende vertegenwoordigt bijvoorbeeld een hello_world tekenreeks hello_world toont die we eerder hebben gedefinieerd:

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

U kunt ook toegang krijgen tot <string> bronnen vanuit het Java-gedeelte van uw app. Om onze dezelfde hello_world reeks van bovenaf op te roepen binnen een activiteitsklasse, gebruikt u:

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

Definieer tekenreeksmatrix

Om een string-array te definiëren, schrijft u in een resource-bestand

res / waarden / filename.xml

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

bijvoorbeeld

res / waarden / arrays.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>

en gebruik het van Java zoals

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

uitgang

I/TAG: [HelloWorld, Hello World!]

Definieer dimensies

Dimensies worden meestal opgeslagen in de bestandsnamen dimens.xml een bron. Ze worden gedefinieerd met behulp van een <dimen> -element.

res / waarden / 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> 

U kunt verschillende eenheden gebruiken:

• sp: Schaalonafhankelijke pixels. Voor lettertypen.
• dp: Density-onafhankelijke pixels. Voor al het andere.
• pt: punten
• px: pixels
• mm: millimeter
• im: inches

Naar dimensies kan nu in XML worden verwezen met de syntaxis @dimen/name_of_the_dimension .

Bijvoorbeeld:

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

Definieer gehele getallen

Gehele getallen worden meestal opgeslagen in een bronbestand met de naam integers.xml , maar de bestandsnaam kan willekeurig worden gekozen. Elk geheel getal wordt gedefinieerd met behulp van een <integer> -element, zoals weergegeven in het volgende bestand:

res / waarden / integers.xml

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

Naar @integer/name_of_the_integer getallen kan nu in XML worden verwezen met de syntaxis @integer/name_of_the_integer , zoals getoond in het volgende voorbeeld:

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

Definieer integer array

Om een integer array te definiëren, schrijft u in een resourcebestand

res / waarden / filename.xml

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

bijvoorbeeld

res / waarden / arrays.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>

en gebruik het van Java zoals

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

uitgang

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

Definieer kleuren

Kleuren worden meestal opgeslagen in een bronbestand met de naam colors.xml in de map /res/values/ .

Ze worden gedefinieerd door <color> -elementen:

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

Kleuren worden voorgesteld door hexadecimale kleurwaarden voor elk kleurkanaal (0 - FF) in een van de volgende indelingen:

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

Legende

• A - alfakanaal - 0-waarde is volledig transparant, FF-waarde is ondoorzichtig
• R - rood kanaal
• G - groen kanaal
• B - blauw kanaal

Gedefinieerde kleuren kunnen in XML worden gebruikt met de volgende syntaxis @color/name_of_the_color

Bijvoorbeeld:

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

Kleuren gebruiken in code

In deze voorbeelden wordt ervan uitgegaan dat this een activiteitsreferentie is. In plaats daarvan kan ook een contextverwijzing worden gebruikt.

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);

In de bovenstaande verklaring worden colorPrimary , colorPrimaryDark en colorAccent gebruikt om materiaalontwerpkleuren te definiëren die worden gebruikt bij het definiëren van een aangepast Android-thema in styles.xml . Ze worden automatisch toegevoegd wanneer een nieuw project wordt gemaakt met Android Studio.

Bronnen verkrijgen zonder "verouderde" waarschuwingen

Met behulp van de Android API 23 of hoger kan een dergelijke situatie vaak worden gezien:

Deze situatie wordt veroorzaakt door de structurele wijziging van de Android API met betrekking tot het verkrijgen van de bronnen.
Nu de functie:

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

zou gebruikt moeten worden. Maar de android.support.v4 bibliotheek heeft een andere oplossing.

Voeg de volgende afhankelijkheid toe aan het bestand build.gradle :

com.android.support:support-v4:24.0.0

Dan zijn alle methoden uit de ondersteuningsbibliotheek beschikbaar:

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));

Bovendien kunnen meer methoden uit de ondersteuningsbibliotheek worden gebruikt:

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

Definieer een menubron en gebruik deze in Activiteit / fragment

Definieer een menu in 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>

Raadpleeg voor meer configuratie-opties: Menubron

Binnen Activity :

@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);
}

Voor het aanroepen van de bovenstaande methoden tijdens het weergeven van de weergave, roept u getActivity().invalidateOptionsMenu();

Inside Fragment een extra oproep nodig:

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

Stringopmaak in strings.xml

Door strings in het bestand strings.xml te definiëren, kunt u ook string opmaken. Het enige voorbehoud is dat de String moet worden afgehandeld in code zoals hieronder, in plaats van deze eenvoudig aan een lay-out te koppelen.

<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);

In bovenstaand voorbeeld
% 1 $ s
'%' scheidt zich van normale tekens,
'1' geeft de eerste parameter aan,
'$' wordt gebruikt als scheidingsteken tussen parameternummer en type,
's' geeft het stringtype aan ('d' wordt gebruikt voor geheel getal)

Merk op dat getString() een methode van Context of Resources , dat wil zeggen dat u het direct in een Activity kunt gebruiken, of anders kunt u getActivity().getString() of getContext().getString() gebruiken.

Definieer een kleurstatuslijst

Kleurstatuslijsten kunnen als kleuren worden gebruikt, maar veranderen afhankelijk van de status van de weergave waarvoor ze worden gebruikt.

Maak een bronbestand in res/color/foo.xml om er een te definiëren

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

Items worden geëvalueerd in de volgorde waarin ze zijn gedefinieerd en het eerste item waarvan de opgegeven status overeenkomt met de huidige status van de weergave wordt gebruikt. Het is dus een goede gewoonte om aan het eind een catch-all te specificeren, zonder dat er staatsselectors zijn opgegeven.

Elk item kan een letterlijke kleur gebruiken of verwijzen naar een kleur die ergens anders is gedefinieerd.

Definieer String Meervoudsvormen

Om onderscheid te maken tussen meervouds- en enkelvoudige tekenreeksen, kunt u een meervoud definiëren in uw bestand strings.xml en de verschillende hoeveelheden vermelden, zoals in het onderstaande voorbeeld:

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

Deze definitie is toegankelijk vanuit Java-code met behulp van de methode getQuantityString() van de klasse Resources , zoals in het volgende voorbeeld:

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

Hier is de eerste parameter R.plurals.hello_people de R.plurals.hello_people . De tweede parameter ( 3 in dit voorbeeld) wordt gebruikt om de juiste quantity te kiezen. De derde parameter (ook 3 in dit voorbeeld) is het opmaakargument dat zal worden gebruikt voor het vervangen van de opmaakspecificatie %d .

Mogelijke hoeveelheidswaarden (weergegeven in alfabetische volgorde) zijn:

few
many
one
other
two
zero

Het is belangrijk op te merken dat niet alle locaties elke denominatie van quantity . De Chinese taal heeft bijvoorbeeld geen concept van one item. Engels heeft geen zero , omdat het grammaticaal hetzelfde is als het other . Niet-ondersteunde exemplaren van de quantity worden door de IDE gemarkeerd als Lint-waarschuwingen, maar veroorzaken geen complicatiefouten als ze worden gebruikt.

Array van objecten importeren die zijn gedefinieerd in bronnen

Er zijn gevallen waarin aangepaste objecten moeten worden gemaakt en gedefinieerd in de bronnen van de toepassing. Dergelijke objecten kunnen bestaan uit eenvoudige Java typen, bijvoorbeeld Integer , Float , String .

Hier is het voorbeeld van het importeren van een object dat is gedefinieerd in toepassingsbronnen. Het object Category bevat 3 eigenschappen van categorie:

• ID kaart
• Kleur
• Naam

Deze POJO heeft zijn equivalent in categories.xml bestand, waarbij elke array dezelfde eigenschappen heeft die voor elke categorie zijn gedefinieerd.

1. Maak een model voor uw object:

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. Maak het bestand in de map res/values :

categories.xml

3. Stel elk model samen dat bestaat uit bronnen:

<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. Definieer een array in het bronnenbestand:

   <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. Maak een functie om ze te importeren:

   @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 patches

9 Patches zijn rekbare afbeeldingen waarin de gebieden die kunnen worden uitgerekt worden gedefinieerd door zwarte markeringen op een transparante rand.

Er is een geweldige tutorial hier .
Ondanks dat het zo oud is, is het nog steeds zo waardevol en het heeft velen van ons geholpen de 9 patch-uitrusting diep te begrijpen.

Helaas is die pagina sinds een tijdje neergelegd (hij is momenteel weer op).

Vandaar de noodzaak om een fysieke kopie van die pagina te hebben voor Android-ontwikkelaars op onze betrouwbare server (s).

Hier is het.

EEN EENVOUDIGE GIDS VOOR 9-PATCH VOOR ANDROID UI 18 mei 2011

Terwijl ik aan mijn eerste Android-app werkte, vond ik 9-patch (aka 9.png) verwarrend en slecht gedocumenteerd. Na een tijdje merkte ik eindelijk hoe het werkte en besloot ik iets samen te gooien om anderen te helpen erachter te komen.

Kortom, 9-patch maakt gebruik van png-transparantie om een geavanceerde vorm van 9-slice of scale9 te doen. De hulplijnen zijn rechte zwarte lijnen van 1 pixel aan de rand van uw afbeelding die de schaal en opvulling van uw afbeelding bepalen. Door uw afbeeldingsbestandnaam.9.png te noemen, herkent Android het 9.png-formaat en gebruikt de zwarte hulplijnen om uw bitmaps te schalen en te vullen.

Hier is een eenvoudige gidskaart:

Zoals je kunt zien, heb je hulplijnen aan elke kant van je afbeelding. De hulplijnen TOP en LINKS zijn voor het schalen van uw afbeelding (bijv. 9-delig), terwijl de hulplijnen RECHTS en ONDER het vulgebied definiëren.

De zwarte hulplijnen worden afgesneden / verwijderd van uw afbeelding - ze worden niet weergegeven in de app. Gidsen mogen slechts één pixel breed zijn, dus als u een 48 × 48-knop wilt, is uw png eigenlijk 50 × 50. Alles wat dikker is dan één pixel, blijft deel uitmaken van uw afbeelding. (Mijn voorbeelden hebben 4-pixel brede hulplijnen voor betere zichtbaarheid. Ze zouden eigenlijk slechts 1-pixel moeten zijn).

Uw gidsen moeten effen zwart zijn (# 000000). Zelfs een klein verschil in kleur (# 000001) of alfa zal ervoor zorgen dat het faalt en normaal uitrekt. Dit falen zal ook niet duidelijk zijn *, het faalt stil! Ja. Werkelijk. Nu weet je het.

Houd er ook rekening mee dat het resterende gebied van de omtrek van één pixel volledig transparant moet zijn. Dit omvat de vier hoeken van de afbeelding - die moeten altijd duidelijk zijn. Dit kan een groter probleem zijn dan u zich realiseert. Als u bijvoorbeeld een afbeelding in Photoshop schaalt, worden er pixels met anti-aliasing toegevoegd, die mogelijk bijna onzichtbare pixels bevatten, waardoor deze ook kan mislukken *. Als u moet schalen in Photoshop, gebruikt u de instelling Dichtstbijzijnde buur in het vervolgkeuzemenu Resample Afbeelding (onder in het pop-upmenu Afbeeldingsgrootte) om scherpe randen op uw hulplijnen te behouden.

* (bijgewerkt 1/2012) Dit is eigenlijk een "fix" in de nieuwste dev-kit. Eerder zou het zich manifesteren als al uw andere afbeeldingen en bronnen die plotseling breken, niet de daadwerkelijk gebroken 9-patch afbeelding.

De TOP- en LEFT-hulplijnen worden gebruikt om het schaalbare deel van uw afbeelding te definiëren - LEFT voor schaalhoogte, TOP voor schaalbreedte. Als u een knopafbeelding als voorbeeld gebruikt, betekent dit dat de knop horizontaal en verticaal binnen het zwarte gedeelte kan worden uitgerekt en dat al het andere, zoals de hoeken, dezelfde grootte blijft. Hiermee kunt u knoppen hebben die in elke grootte kunnen worden geschaald en een uniform uiterlijk behouden.

Het is belangrijk op te merken dat afbeeldingen met 9 vlakken niet verkleinen - ze vergroten alleen. Het is dus het beste om zo klein mogelijk te beginnen.

U kunt ook delen in het midden van de schaallijn weglaten. Als u bijvoorbeeld een knop met een scherpe glanzende rand in het midden hebt, kunt u een paar pixels in het midden van de LINKER gids weglaten. De middelste horizontale as van uw afbeelding wordt niet geschaald, alleen de delen erboven en eronder, dus uw scherpe glans krijgt geen anti-aliasing of wazig.

Vulgebiedgidsen zijn optioneel en bieden een manier om het gebied te definiëren voor dingen zoals uw tekstlabel. Opvulling bepaalt hoeveel ruimte er in uw afbeelding is om tekst, een pictogram of andere dingen te plaatsen. 9-patch is niet alleen voor knoppen, het werkt ook voor achtergrondafbeeldingen.

Het bovenstaande voorbeeld van knop en label is overdreven om het idee van opvulling uit te leggen - het label is niet helemaal nauwkeurig. Om eerlijk te zijn, heb ik niet ervaren hoe Android labels met meerdere regels gebruikt, omdat een knoplabel meestal een enkele rij tekst is.

Tot slot is hier een goede demonstratie van hoe schaal- en vulgidsen kunnen variëren, zoals een lineaire lay-out met een achtergrondafbeelding en volledig afgeronde zijden:

In dit voorbeeld wordt de LEFT-gids niet gebruikt, maar we moeten nog steeds een gids hebben. De achtergrondafbeelding schaalt niet verticaal; het schaalt gewoon horizontaal (gebaseerd op de TOP-gids). Kijkend naar de vulgeleiders, reiken de RECHTER- en ONDER-hulplijnen verder dan waar ze de gebogen randen van de afbeelding ontmoeten. Hierdoor kan ik mijn ronde knoppen dicht bij de randen van de achtergrond plaatsen voor een strakke, aansluitende look.

Dus dat is het. 9-patch is super eenvoudig, als je het eenmaal hebt. Het is geen perfecte manier om te schalen, maar de vulgeleiders en schaalregelaars met meerdere regels bieden meer flexibiliteit dan traditionele 9-delige en schaal9. Probeer het eens en u zult het snel uitzoeken.

Kleurentransparantie (alfa) niveau

Hex-dekkingswaarden

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

Als u 45% op rode kleur wilt instellen.

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

hexadecimale waarde voor rood - # FF0000

U kunt 73 toevoegen voor 45% dekking in het voorvoegsel - # 73FF0000

Werken met het bestand strings.xml

Een tekenreeksbron biedt tekststrings voor uw toepassing met optionele tekststijl en opmaak. Er zijn drie soorten bronnen die uw toepassing van strings kunnen voorzien:

Draad

XML resource that provides a single string.

Syntaxis:

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

En om deze tekenreeks in de lay-out te gebruiken:

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

String Array

XML resource that provides an array of strings.

Syntaxis:

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

Gebruik

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

Hoeveelheidsreeksen (meervoudsvormen)

XML resource that carries different strings for pluralization. 

Syntaxis:

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

Gebruik:

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