Diese Seite wurde von der Cloud Translation API übersetzt.

Stringressourcen

Eine Stringressource stellt Textstrings für Ihre Anwendung mit optionalen Textstilen und ‐formatierungen bereit. Es gibt drei Arten von Ressourcen, die Ihre Anwendung mit Strings versorgen können:

String: XML-Ressource, die einen einzelnen String bereitstellt.
String-Array: XML-Ressource, die ein String-Array bereitstellt.
Mengenstrings (Plurale): XML-Ressource, die verschiedene Strings für die Pluralbildung enthält.

Auf alle Strings können bestimmte Stil-Markups und Formatierungsargumente angewendet werden. Informationen zu Stilen und Formatierungen von Strings finden Sie im Abschnitt Formatierung und Stile.

String

Ein einzelner String, auf den in der Anwendung oder in anderen Ressourcendateien (z. B. einem XML-Layout) verwiesen werden kann.

Hinweis: Ein String ist eine einfache Ressource, auf die mit dem Wert im Attribut name (nicht mit dem Namen der XML-Datei) verwiesen wird. So können Sie Stringressourcen mit anderen einfachen Ressourcen in einer XML-Datei unter einem <resources>-Element kombinieren.

Dateispeicherort:

res/values/filename.xml
Der Dateiname ist beliebig. Der name des <string>-Elements wird als Ressourcen-ID verwendet.

kompilierter Ressourcentyp:

Ressourcenverweis auf eine String.

Ressourcenreferenz:

In Java: R.string.string_name
In XML:@string/string_name

Syntax:

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

Elemente:

Beispiel:

XML-Datei gespeichert unter res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello!</string>
</resources>

Diese Layout-XML wendet einen String auf eine Ansicht an:

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

Mit diesem Anwendungscode wird ein String abgerufen:

Kotlin

val string: String = getString(R.string.hello)

Java

String string = getString(R.string.hello);

Sie können entweder getString(int) oder getText(int) verwenden, um einen String abzurufen. Bei getText(int) werden alle auf den String angewendeten Rich-Text-Stile beibehalten.

String-Array

Ein Array von Strings, auf das in der Anwendung verwiesen werden kann.

Hinweis: Ein String-Array ist eine einfache Ressource, auf die mit dem Wert im Attribut name (nicht mit dem Namen der XML-Datei) verwiesen wird. So können Sie String-Array-Ressourcen mit anderen einfachen Ressourcen in einer XML-Datei unter einem <resources>-Element kombinieren.

Dateispeicherort:

res/values/filename.xml
Der Dateiname ist beliebig. Der name des <string-array>-Elements wird als Ressourcen-ID verwendet.

kompilierter Ressourcentyp:

Ressourcenzeiger auf ein Array von Strings.

Ressourcenreferenz:

In Java: R.array.string_array_name
In XML: @[package:]array/string_array_name

Syntax:

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

Elemente:

Beispiel:

XML-Datei gespeichert unter res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="planets_array">
        <item>Mercury</item>
        <item>Venus</item>
        <item>Earth</item>
        <item>Mars</item>
    </string-array>
</resources>

Mit diesem Anwendungscode wird ein String-Array abgerufen:

Kotlin

val array: Array<String> = resources.getStringArray(R.array.planets_array)

Java

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

Mengenstrings (Pluralformen)

Verschiedene Sprachen haben unterschiedliche Regeln für die grammatische Übereinstimmung mit der Quantität. Im Englischen ist zum Beispiel die Menge 1 ein Sonderfall. Wir schreiben „1 Buch“, aber für jede andere Menge schreiben wir n Bücher. Diese Unterscheidung zwischen Singular und Plural ist sehr häufig, aber in anderen Sprachen unterscheiden sich feinere Unterschiede. Alle von Android unterstützten Geräte sind zero, one, two, few, many und other.

Die Regeln für die Entscheidung, welcher Fall für eine bestimmte Sprache und Menge verwendet werden soll, können sehr komplex sein. Daher bietet Android Methoden wie getQuantityString() an, mit denen du die geeignete Ressource für dich auswählen kannst.

Obwohl Mengenstrings bisher als „Mengenstrings“ bezeichnet wurden (und in der API immer noch genannt werden), sollten Mengenstrings nur für Pluralformen verwendet werden. Es wäre ein Fehler, Mengenzeichenfolgen zu verwenden, um etwas wie „Posteingang“ in Gmail im Vergleich zu „Posteingang (12)“ zu implementieren, wenn beispielsweise ungelesene Nachrichten vorhanden sind. Es mag praktisch erscheinen, Mengenstrings anstelle einer if-Anweisung zu verwenden. Beachten Sie jedoch, dass bei einigen Sprachen (z. B. Chinesisch) diese grammatikalischen Unterscheidungen überhaupt nicht vorgenommen werden. Daher erhalten Sie immer den String other.

Die Auswahl der zu verwendenden Zeichenfolge beruht ausschließlich auf einer grammatikalischen Notwendigkeit. Im Englischen wird ein String für zero ignoriert, auch wenn die Menge 0 ist, da sich 0 grammatikalisch nicht von 2 oder einer anderen Zahl außer 1 unterscheidet („null Bücher“, „ein Buch“, „zwei Bücher“ usw.). Im Gegensatz dazu wird im Koreanischen nur der String other verwendet.

Lassen Sie sich auch nicht täuschen, etwa dadurch, dass two nur für die Menge 2 gelten könnte: Für eine Sprache kann es erforderlich sein, dass 2, 12, 102 usw. alle wieeinander behandelt werden, aber andere Größen unterscheiden. Der Übersetzer muss wissen, worauf seine Sprache wirklich besteht.

Wenn in Ihrer Nachricht keine Mengenzahl enthalten ist, ist sie wahrscheinlich kein guter Plural als Plural. Im Litauisch wird beispielsweise der Singular sowohl für 1 als auch für 101 verwendet, sodass „1 Buch“ als „1 Kyga“ und „101 Bücher“ als „101 Kyga“ übersetzt wird. „ein Buch“ heißt „Kyga“ und „viele Bücher“ heißt „daug knygЋ“. Wenn eine englische Pluralnachricht „ein Buch“ (Singular) und „viele Bücher“ (Plural) ohne die tatsächliche Zahl enthält, kann es als „knyga“ (ein Buch)/„daug knygЋ“ (viele Bücher) übersetzt werden. Nach litauischen Regeln wird jedoch „knyga“ (ein einzelnes Buch) angezeigt, wenn die Zahl 101 ist.

Mengenstrings können häufig vermieden werden, indem mengenneutrale Schreibweisen wie "Bücher: 1" verwendet werden. Dies erleichtert Ihnen und Ihren Übersetzern das Leben, wenn der Stil für Ihre Anwendung akzeptabel ist.

Ab API 24 können Sie stattdessen die viel leistungsstärkere ICU-Klasse MessageFormat verwenden.

Hinweis:Eine Pluralsammlung ist eine einfache Ressource, auf die mit dem Wert im Attribut name und nicht mit dem Namen der XML-Datei verwiesen wird. So können Sie Pluralressourcen mit anderen einfachen Ressourcen in einer XML-Datei unter einem <resources>-Element kombinieren.

Dateispeicherort:

res/values/filename.xml
Der Dateiname ist beliebig. Der name des <plurals>-Elements wird als Ressourcen-ID verwendet.

Ressourcenreferenz:

In Java: R.plurals.plural_name

Syntax:

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

Elemente:

<resources>

Erforderlich. Das muss der Root-Knoten sein.

Keine Attribute.

<plurals>

Eine Sammlung von Strings, von denen je nach Länge ein String bereitgestellt wird. Enthält ein oder mehrere <item>-Elemente.

Attribute:

name: String Ein Name für das Stringpaar. Dieser Name wird als Ressourcen-ID verwendet.

<item>

Ein Plural oder Singular String Der Wert kann ein Verweis auf eine andere Stringressource sein. Muss einem <plurals>-Element untergeordnet sein. Apostrophe und Anführungszeichen müssen mit Escape-Zeichen versehen werden. Im Abschnitt Formatierung und Stil unten finden Sie Informationen zum richtigen Stil und Format von Strings.

Attribute:

quantity

Keyword. Ein Wert, der angibt, wann dieser String verwendet werden soll. Gültige Werte mit nicht vollständigen Beispielen in Klammern:

Antwort	Beschreibung
`zero`	Wenn in der Sprache eine besondere Behandlung der Zahl 0 erforderlich ist (wie auf Arabisch).
`one`	Wenn in der Sprache eine besondere Behandlung von Zahlen wie der Eins erforderlich ist (z. B. die Zahl 1 im Englischen und die meisten anderen Sprachen; im Russischen wird jede Zahl in diese Klasse aufgenommen, die auf 1 enden, aber nicht auf 11 endet).
`two`	Wenn in der Sprache eine besondere Behandlung von Zahlen wie zwei erforderlich ist (z. B. 2 auf Walisisch oder 102 auf Slowenisch).
`few`	Wenn in der Sprache eine besondere Behandlung „kleiner“ Zahlen erforderlich ist (z. B. 2, 3 und 4 auf Tschechisch oder Zahlen, die auf 2, 3 oder 4 enden, aber nicht auf 12, 13 oder 14 auf Polnisch).
`many`	Wenn in der Sprache eine besondere Behandlung „großer“ Zahlen erforderlich ist (z. B. Zahlen, die auf Maltesisch mit 11–99 enden).
`other`	Wenn die angegebene Menge in der Sprache nicht gesondert behandelt werden muss (wie bei allen Ziffern auf Chinesisch oder 42 auf Englisch).

Beispiel:

XML-Datei gespeichert unter res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <!--
             As a developer, you should always supply "one" and "other"
             strings. Your translators will know which strings are actually
             needed for their language. Always include %d in "one" because
             translators will need to use %d for languages where "one"
             doesn't mean 1 (as explained above).
          -->
        <item quantity="one">%d song found.</item>
        <item quantity="other">%d songs found.</item>
    </plurals>
</resources>

XML-Datei gespeichert unter res/values-pl/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <item quantity="one">Znaleziono %d piosenkę.</item>
        <item quantity="few">Znaleziono %d piosenki.</item>
        <item quantity="other">Znaleziono %d piosenek.</item>
    </plurals>
</resources>

Verwendung:

Kotlin

val count = getNumberOfSongsAvailable()
val songsFound = resources.getQuantityString(R.plurals.numberOfSongsAvailable, count, count)

Java

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

Bei Verwendung der Methode getQuantityString() müssen Sie count zweimal übergeben, wenn der String eine Stringformatierung mit einer Zahl enthält. Für den String %d songs found wählt beispielsweise der erste Parameter count den entsprechenden Pluralstring aus und der zweite count-Parameter wird in den Platzhalter %d eingefügt. Wenn Ihre Pluralstrings keine Stringformatierung enthalten, müssen Sie den dritten Parameter nicht an getQuantityString übergeben.

Format und Stil

Im Folgenden finden Sie einige wichtige Informationen zum richtigen Formatieren und Gestalten Ihrer Stringressourcen.

Umgang mit Sonderzeichen

Wenn ein String Zeichen enthält, die in XML besonders häufig verwendet werden, müssen Sie die Zeichen gemäß den standardmäßigen XML/HTML-Escape-Regeln mit Escape-Zeichen versehen. Falls Sie ein Zeichen, das in Android eine besondere Bedeutung hat, mit Escapezeichen versehen müssen, sollten Sie einen umgekehrten Schrägstrich davor verwenden.

Sequenzen von Leerzeichen werden von Android standardmäßig in einem einzelnen Leerzeichen minimiert. Sie können das vermeiden, indem Sie den relevanten Teil Ihrer Zeichenfolge in doppelte Anführungszeichen setzen. In diesem Fall werden alle Leerzeichen (einschließlich neuer Zeilen) innerhalb des in Anführungszeichen gesetzten Bereichs beibehalten. Mit doppelten Anführungszeichen können Sie auch einfache einfache Anführungszeichen ohne Escape-Zeichen verwenden.

Zeichen	Maskierte Formulare
@	`\@`
?	`\?`
Neue Zeile	`\n`
Tabulatortaste	`\t`
U+XXXX Unicode-Zeichen	`\uXXXX`
Einfaches Anführungszeichen (`'`)	Eine der folgenden Optionen: `\'` Setzen Sie den gesamten String in doppelte Anführungszeichen (z. B. `"This'll work"`).
Doppeltes Anführungszeichen (`"`)	`\"` Der String kann nicht in einfache Anführungszeichen gesetzt werden.

Die Leerzeichen werden minimiert und die Android-Escaping-Funktion wird verwendet, nachdem die Ressourcendatei als XML geparst wurde. Das bedeutet, dass <string>    </string> (Leerzeichen, Satzzeichen, Unicode-Em-Leerzeichen) alle zu einem einzelnen Leerzeichen (" ") minimiert werden, da es sich nach dem Parsen der Datei als XML-Datei um Unicode-Bereiche handelt. Wenn Sie diese Leerzeichen unverändert lassen möchten, können Sie sie entweder in Anführungszeichen setzen (<string>"    "</string>) oder Android-Escapezeichen verwenden (<string> \u0032 \u8200 \u8195</string>).

Hinweis: Aus Sicht des XML-Parsers gibt es überhaupt keinen Unterschied zwischen <string>"Test this"</string> und <string>"Test this"</string>. Beide Formen zeigen keine Anführungszeichen an, lösen jedoch Leerzeichen-erhaltende Anführungszeichen von Android aus (in diesem Fall hat dies keine praktische Wirkung).

Strings formatieren

Wenn Sie Strings formatieren müssen, können Sie dafür die Formatargumente in die String-Ressource einfügen, wie in der folgenden Beispielressource gezeigt.

<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string>

In diesem Beispiel hat der Formatstring zwei Argumente: %1$s ist ein String und %2$d eine Dezimalzahl. Formatieren Sie dann den String, indem Sie getString(int, Object...) aufrufen. Beispiele:

Kotlin

var text = getString(R.string.welcome_messages, username, mailCount)

Java

String text = getString(R.string.welcome_messages, username, mailCount);

Stile mit HTML-Markup erstellen

Mit HTML-Markup können Sie Ihren Strings Stile hinzufügen. Beispiele:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="welcome">Welcome to <b>Android</b>!</string>
</resources>

Die folgenden HTML-Elemente werden unterstützt:

Fett:
Kursiv: , <cite>, <FILENAME>,
25% größerer Text: <big>
20% kleinerer Text:
Schrifteigenschaften werden festgelegt: . Beispiele für mögliche Schriftfamilien sind monospace, serif und sans_serif.
Festbreitenschrift festlegen: <tt>
Durchstreichen: <s>, <strike>, <del>
Unterstrichen:
Hochgestellt:
Tiefgestellt:
Aufzählungspunkte: <ul>, <li>
Zeilenumbrüche:
Division: <div>
CSS-Stil:
Absätze:

Wenn du keine Formatierung anwendest, kannst du TextView-Text direkt durch Aufrufen von setText(java.lang.CharSequence) festlegen. In manchen Fällen möchten Sie jedoch möglicherweise eine Textressource mit benutzerdefinierten Stilen erstellen, die auch als Formatstring verwendet wird. Dies funktioniert normalerweise nicht, da bei den Methoden format(String, Object...) und getString(int, Object...) alle Stilinformationen aus dem String entfernt werden. Um das zu umgehen, müssen Sie die HTML-Tags mit Entitäten mit Escape-Zeichen schreiben, die nach der Formatierung mit fromHtml(String) wiederhergestellt werden. Beispiele:

Speichern Sie Ihre Textressource mit benutzerdefinierten Stilen als HTML-Escaping-String:
```
<resources>
 <string name="welcome_messages">Hello, %1$s! You have &lt;b>%2$d new messages&lt;/b>.</string>
</resources>
```
In diesem formatierten String wird ein -Element hinzugefügt. Die öffnende Klammer ist HTML-maskiert und verwendet die Notation <.

Formatieren Sie dann den String wie gewohnt, rufen Sie aber zusätzlich fromHtml(String) auf, um den HTML-Text in formatierten Text umzuwandeln:

Kotlin

val text: String = getString(R.string.welcome_messages, username, mailCount)
val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY)

Java

String text = getString(R.string.welcome_messages, username, mailCount);
Spanned styledText = Html.fromHtml(text, FROM_HTML_MODE_LEGACY);

Da die Methode fromHtml(String) alle HTML-Entitäten formatiert, müssen Sie alle möglichen HTML-Zeichen in den Strings, die Sie mit dem formatierten Text verwenden, mit htmlEncode(String) maskieren. Wenn Sie beispielsweise einen String formatieren, der Zeichen wie „<“ oder „&“ enthält, müssen diese vor der Formatierung mit Escapezeichen versehen werden. Wenn der formatierte String über fromHtml(String) übergeben wird, müssen die Zeichen so wie ursprünglich geschrieben werden. Beispiele:

Kotlin

val escapedUsername: String = TextUtils.htmlEncode(username)

val text: String = getString(R.string.welcome_messages, escapedUsername, mailCount)
val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY)

Java

String escapedUsername = TextUtils.htmlEncode(username);

String text = getString(R.string.welcome_messages, escapedUsername, mailCount);
Spanned styledText = Html.fromHtml(text);

Stile mit Spannables erstellen

Ein Spannable ist ein Textobjekt, das Sie mit Schrifteigenschaften wie Farbe und Schriftstärke gestalten können. Sie erstellen den Text mit SpannableStringBuilder und wenden dann die im Paket android.text.style definierten Stile auf den Text an.

Mit den folgenden Hilfsmethoden können Sie einen Großteil der Arbeit beim Erstellen von spannablem Text erledigen:

Kotlin

/**
 * Returns a CharSequence that concatenates the specified array of CharSequence
 * objects and then applies a list of zero or more tags to the entire range.
 *
 * @param content an array of character sequences to apply a style to
 * @param tags the styled span objects to apply to the content
 *        such as android.text.style.StyleSpan
 */
private fun apply(content: Array<out CharSequence>, vararg tags: Any): CharSequence {
    return SpannableStringBuilder().apply {
        openTags(tags)
        content.forEach { charSequence ->
            append(charSequence)
        }
        closeTags(tags)
    }
}

/**
 * Iterates over an array of tags and applies them to the beginning of the specified
 * Spannable object so that future text appended to the text will have the styling
 * applied to it. Do not call this method directly.
 */
private fun Spannable.openTags(tags: Array<out Any>) {
    tags.forEach { tag ->
        setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK)
    }
}

/**
 * "Closes" the specified tags on a Spannable by updating the spans to be
 * endpoint-exclusive so that future text appended to the end will not take
 * on the same styling. Do not call this method directly.
 */
private fun Spannable.closeTags(tags: Array<out Any>) {
    tags.forEach { tag ->
    if (length > 0) {
            setSpan(tag, 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
        } else {
            removeSpan(tag)
        }
    }
}

Java

/**
 * Returns a CharSequence that concatenates the specified array of CharSequence
 * objects and then applies a list of zero or more tags to the entire range.
 *
 * @param content an array of character sequences to apply a style to
 * @param tags the styled span objects to apply to the content
 *        such as android.text.style.StyleSpan
 *
 */
private static CharSequence applyStyles(CharSequence[] content, Object[] tags) {
    SpannableStringBuilder text = new SpannableStringBuilder();
    openTags(text, tags);
    for (CharSequence item : content) {
        text.append(item);
    }
    closeTags(text, tags);
    return text;
}

/**
 * Iterates over an array of tags and applies them to the beginning of the specified
 * Spannable object so that future text appended to the text will have the styling
 * applied to it. Do not call this method directly.
 */
private static void openTags(Spannable text, Object[] tags) {
    for (Object tag : tags) {
        text.setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK);
    }
}

/**
 * "Closes" the specified tags on a Spannable by updating the spans to be
 * endpoint-exclusive so that future text appended to the end will not take
 * on the same styling. Do not call this method directly.
 */
private static void closeTags(Spannable text, Object[] tags) {
    int len = text.length();
    for (Object tag : tags) {
        if (len > 0) {
            text.setSpan(tag, 0, len, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        } else {
            text.removeSpan(tag);
        }
    }
}

Die folgenden Methoden bold, italic und color umschließen die oben genannten Hilfsmethoden und zeigen spezifische Beispiele für die Anwendung der im Paket android.text.style definierten Stile. Sie können ähnliche Methoden für andere Arten von Textstilen erstellen.

Kotlin

/**
 * Returns a CharSequence that applies boldface to the concatenation
 * of the specified CharSequence objects.
 */
fun bold(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.BOLD))

/**
 * Returns a CharSequence that applies italics to the concatenation
 * of the specified CharSequence objects.
 */
fun italic(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.ITALIC))

/**
 * Returns a CharSequence that applies a foreground color to the
 * concatenation of the specified CharSequence objects.
 */
fun color(color: Int, vararg content: CharSequence): CharSequence =
        apply(content, ForegroundColorSpan(color))

Java

/**
 * Returns a CharSequence that applies boldface to the concatenation
 * of the specified CharSequence objects.
 */
public static CharSequence bold(CharSequence... content) {
    return apply(content, new StyleSpan(Typeface.BOLD));
}

/**
 * Returns a CharSequence that applies italics to the concatenation
 * of the specified CharSequence objects.
 */
public static CharSequence italic(CharSequence... content) {
    return apply(content, new StyleSpan(Typeface.ITALIC));
}

/**
 * Returns a CharSequence that applies a foreground color to the
 * concatenation of the specified CharSequence objects.
 */
public static CharSequence color(int color, CharSequence... content) {
    return apply(content, new ForegroundColorSpan(color));
}

Das folgende Beispiel zeigt, wie diese Methoden miteinander verkettet werden, um verschiedene Stile auf einzelne Wörter innerhalb einer Wortgruppe anzuwenden:

Kotlin

// Create an italic "hello, " a red "world",
// and bold the entire sequence.
val text: CharSequence = bold(italic(getString(R.string.hello)),
        color(Color.RED, getString(R.string.world)))

Java

// Create an italic "hello, " a red "world",
// and bold the entire sequence.
CharSequence text = bold(italic(getString(R.string.hello)),
    color(Color.RED, getString(R.string.world)));

Das Kotlin-Modul Core-ktx enthält außerdem Erweiterungsfunktionen, die die Arbeit mit Spans noch einfacher machen. Weitere Informationen finden Sie in der Dokumentation zum Paket android.text auf GitHub.

Weitere Informationen zum Arbeiten mit Spans finden Sie unter den folgenden Links:

Stil mit Anmerkungen

Sie können komplexe oder benutzerdefinierte Stile anwenden, indem Sie die Annotation-Klasse zusammen mit dem <annotation>-Tag in Ihren string.xml-Ressourcendateien verwenden. Mit dem Annotations-Tag können Sie Teile des Strings für benutzerdefinierte Stile kennzeichnen. Dazu definieren Sie in der XML-Datei benutzerdefinierte Schlüssel/Wert-Paare, die vom Framework dann in Annotation-Spans konvertiert werden. Anschließend können Sie diese Annotationen abrufen und mit dem Schlüssel und dem Wert den Stil anwenden.

Beim Erstellen von Anmerkungen musst du das <annotation>-Tag allen Übersetzungen des Strings in jeder string.xml-Datei hinzufügen.

Eine benutzerdefinierte Schriftart auf das Wort „Text“ in allen Sprachen anwenden

Beispiel – Benutzerdefiniertes Schriftbild hinzufügen

Fügen Sie das Tag <annotation> hinzu und definieren Sie das Schlüssel/Wert-Paar. In diesem Fall ist der Schlüssel font und der Wert der Schrifttyp, den wir verwenden möchten: title_emphasis

// values/strings.xml
<string name="title">Best practices for <annotation font="title_emphasis">text</annotation> on Android</string>

// values-es/strings.xml
<string name="title"><annotation font="title_emphasis">Texto</annotation> en Android: mejores prácticas</string>

Laden Sie die String-Ressource und suchen Sie die Annotationen mit dem Schlüssel font. Erstellen Sie dann einen benutzerdefinierten Span und ersetzen Sie den vorhandenen.

Kotlin

// get the text as SpannedString so we can get the spans attached to the text
val titleText = getText(R.string.title) as SpannedString

// get all the annotation spans from the text
val annotations = titleText.getSpans(0, titleText.length, Annotation::class.java)

// create a copy of the title text as a SpannableString.
// the constructor copies both the text and the spans. so we can add and remove spans
val spannableString = SpannableString(titleText)

// iterate through all the annotation spans
for (annotation in annotations) {
   // look for the span with the key font
   if (annotation.key == "font") {
      val fontName = annotation.value
      // check the value associated to the annotation key
      if (fontName == "title_emphasis") {
         // create the typeface
         val typeface = getFontCompat(R.font.permanent_marker)
         // set the span at the same indices as the annotation
         spannableString.setSpan(CustomTypefaceSpan(typeface),
            titleText.getSpanStart(annotation),
            titleText.getSpanEnd(annotation),
            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
      }
   }
}

// now, the spannableString contains both the annotation spans and the CustomTypefaceSpan
styledText.text = spannableString

Java

// get the text as SpannedString so we can get the spans attached to the text
SpannedString titleText = (SpannedString) getText(R.string.title);

// get all the annotation spans from the text
Annotation[] annotations = titleText.getSpans(0, titleText.length(), Annotation.class);

// create a copy of the title text as a SpannableString.
// the constructor copies both the text and the spans. so we can add and remove spans
SpannableString spannableString = new SpannableString(titleText);

// iterate through all the annotation spans
for (Annotation annotation: annotations) {
  // look for the span with the key font
  if (annotation.getKey().equals("font")) {
    String fontName = annotation.getValue();
    // check the value associated to the annotation key
    if (fontName.equals("title_emphasis")) {
    // create the typeface
    Typeface typeface = ResourcesCompat.getFont(this, R.font.roboto_mono);
    // set the span at the same indices as the annotation
    spannableString.setSpan(new CustomTypefaceSpan(typeface),
      titleText.getSpanStart(annotation),
      titleText.getSpanEnd(annotation),
      Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    }
  }
}

// now, the spannableString contains both the annotation spans and the CustomTypefaceSpan
styledText.text = spannableString;

Wenn Sie denselben Text mehrmals verwenden, sollten Sie das SpannableString-Objekt einmal erstellen und bei Bedarf wiederverwenden, um potenzielle Leistungs- und Arbeitsspeicherprobleme zu vermeiden.

Weitere Beispiele für die Verwendung von Annotationen finden Sie unter Internationalisierten Text in Android gestalten.

Annotationsbereiche und Textparceling

Da Annotation-Spans ebenfalls ParcelableSpans sind, sind die Schlüssel/Wert-Paare parzelleniert und unverpackt. Solange der Empfänger des Pakets weiß, wie die Anmerkungen interpretiert werden sollen, können Sie mithilfe von Annotation-Spans benutzerdefinierte Stile auf den Pakettext anwenden.

Wenn Sie den benutzerdefinierten Stil beim Übergeben des Textes an ein Intent-Bundle beibehalten möchten, müssen Sie dem Text zuerst Annotation-Spans hinzufügen. Sie können dies in den XML-Ressourcen über das <annotation>-Tag tun, wie im obigen Beispiel gezeigt, oder im Code, indem Sie einen neuen Annotation erstellen und ihn wie unten gezeigt als Span festlegen:

Kotlin

val spannableString = SpannableString("My spantastic text")
val annotation = Annotation("font", "title_emphasis")
spannableString.setSpan(annotation, 3, 7, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

// start Activity with text with spans
val intent = Intent(this, MainActivity::class.java)
intent.putExtra(TEXT_EXTRA, spannableString)
startActivity(intent)

Java

SpannableString spannableString = new SpannableString("My spantastic text");
Annotation annotation = new Annotation("font", "title_emphasis");
spannableString.setSpan(annotation, 3, 7, 33);

// start Activity with text with spans
Intent intent = new Intent(this, MainActivity.class);
intent.putExtra(TEXT_EXTRA, spannableString);
this.startActivity(intent);

Rufen Sie den Text aus dem Bundle als SpannableString ab und parsen Sie dann die angehängten Annotationen, wie im obigen Beispiel gezeigt.

Kotlin

// read text with Spans
val intentCharSequence = intent.getCharSequenceExtra(TEXT_EXTRA) as SpannableString

Java

// read text with Spans
SpannableString intentCharSequence = (SpannableString)intent.getCharSequenceExtra(TEXT_EXTRA);

Weitere Informationen zu Textstilen finden Sie unter den folgenden Links:

Zurück

Weiter

Style