tamaño - Cómo cambiar la familia de fuentes de TextView en Android

tamaño de letra en android studio

Question

Así que me gustaría cambiar el android:fontFamily en Android pero no veo ninguna fuente predefinida en Android. ¿Cómo selecciono uno de los predefinidos? Realmente no necesito definir mi propio TypeFace, pero todo lo que necesito es algo diferente de lo que muestra ahora.

<TextView
android:id="@+id/HeaderText"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="52dp"
android:gravity="center"
android:text="CallerBlocker"
android:textSize="40dp"
android:fontFamily="Arial"
/>

¡Parece que lo que hice allí realmente no funcionará! BTW android:fontFamily="Arial" fue un intento estúpido!

Answer 1

A partir de Android-Studio 3.0 es muy fácil cambiar la familia de fuentes

Usando la biblioteca de soporte 26, funcionará en dispositivos que ejecuten la API de Android versión 16 y superior

Cree una font carpeta en el directorio res Descargue la fuente que desee y péguela dentro de la carpeta de font . La estructura debe ser algo como abajo.

Ahora puedes cambiar la fuente en el diseño usando

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"/>

Cambiar programáticamente

 Typeface typeface = getResources().getFont(R.font.myfont);
textView.setTypeface(typeface);

Para cambiar la fuente usando styles.xml crea un estilo

 <style name="Regular">
<item name="android:fontFamily">@font/dancing_script</item>
<item name="android:textStyle">normal</item>
</style>

y aplica este estilo a TextView

 <TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
style="@style/Regular"/>

También puedes crear tu propia familia de fuentes.

- Haga clic con el botón derecho en la carpeta de fuentes y vaya a Nuevo> Archivo de recursos de fuentes . Aparece la ventana Nuevo archivo de recursos.

- Ingrese el nombre del archivo , y luego haga clic en Aceptar . El nuevo recurso fuente XML se abre en el editor.

Escribe tu propia familia de fuentes aquí, por ejemplo

<font-family xmlns:android="http://schemas.android.com/apk/res/android">
<font
android:fontStyle="normal"
android:fontWeight="400"
android:font="@font/lobster_regular" />
<font
android:fontStyle="italic"
android:fontWeight="400"
android:font="@font/lobster_italic" />
</font-family>

esto es simplemente una asignación de un fontStyle y fontWeight específicos al recurso de fuente que se utilizará para representar esa variante específica. Los valores válidos para fontStyle son normal o cursiva; y fontWeight se ajusta a la especificación de peso de fuente CSS

1. Para cambiar la familia de fuentes en el diseño puedes escribir

 <TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/lobster"/>

2. Cambiar programáticamente

 Typeface typeface = getResources().getFont(R.font.myfont);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
textView.setTypeface(typeface);

Nota: a partir de la biblioteca de soporte de Android 26.0, debe declarar ambos conjuntos de atributos (android: y app:) para asegurar que sus fuentes se carguen en dispositivos que ejecuten Api 26 o inferior.

 <?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<font android:fontStyle="normal" android:fontWeight="400" android:font="@font/myfont-Regular"
app:fontStyle="normal" app:fontWeight="400" app:font="@font/myfont-Regular"/>
<font android:fontStyle="italic" android:fontWeight="400" android:font="@font/myfont-Italic"
app:fontStyle="italic" app:fontWeight="400" app:font="@font/myfont-Italic" />
</font-family>

Para cambiar la fuente de la aplicación completa, agregue estas dos líneas en AppTheme

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<item name="android:fontFamily">@font/your_font</item>
<item name="fontFamily">@font/your_font</item>
</style>

Vea la Documentation , tutorial de fuentes personalizadas de Android para más información

Answer 2

Android no le permite establecer fuentes personalizadas desde el diseño XML. En su lugar, debe agrupar el archivo de fuente específico en la carpeta de activos de su aplicación y configurarlo mediante programación. Algo como:

TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);

Tenga en cuenta que solo puede ejecutar este código después de que se haya llamado a setContentView (). Además, solo algunas fuentes son compatibles con Android, y deben estar en .ttf (TrueType) o .otf (OpenType) . Incluso entonces, algunas fuentes pueden no funcionar.

This es una fuente que definitivamente funciona en Android, y puede usarla para confirmar que su código funciona en caso de que su fuente no sea compatible con Android.

Actualización de Android O: ahora es posible con XML en Android O , según el comentario de Roger.

Answer 3

Aquí hay una forma más fácil de trabajar en algunos casos. El principio es agregar un TextVview no visible en su diseño xml y obtener su TypeFace en el código java.

El diseño en el archivo xml:

 <TextView
android:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."
android:layout_width="0dp"
android:layout_height="0dp"
android:fontFamily="sans-serif-thin"
android:id="@+id/textViewDescription"/>

Y el código java:

myText.setTypeface(textViewSelectedDescription.getTypeface());

Me ha funcionado (por ejemplo, dentro de un TextSwitcher).

Answer 4

Con un poco de prueba y error aprendí lo siguiente.

Dentro del * .xml puede combinar las fuentes comunes con las siguientes funciones, no solo con el tipo de letra:

 android:fontFamily="serif"
android:textStyle="italic"

Con estos dos estilos, no había necesidad de usar tipografía en ningún otro caso. El rango de combinaciones es mucho más grande con fontfamily & textStyle.

Answer 5

Desde Android 4.1 / 4.2 / 5.0, las siguientes familias de fuentes Roboto están disponibles:

android:fontFamily="sans-serif" // roboto regular
android:fontFamily="sans-serif-light" // roboto light
android:fontFamily="sans-serif-condensed" // roboto condensed
android:fontFamily="sans-serif-black" // roboto black
android:fontFamily="sans-serif-thin" // roboto thin (android 4.2)
android:fontFamily="sans-serif-medium" // roboto medium (android 5.0)

en combinación con

android:textStyle="normal|bold|italic"

estas 16 variantes son posibles:

• Roboto regular
• Roboto cursiva
• Roboto negrita
• Roboto negrita cursiva
• Roboto-Light
• Roboto-Light cursiva
• Roboto-Thin
• Roboto-Thin cursiva
• Roboto Condensado
• Cursiva robot-condensada
• Roboto Condensado en negrita
• Roboto Condensado negrita cursiva
• Roboto-negro
• Roboto-Black Italic
• Roboto-Medio
• Roboto-medio cursiva

fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="font_family_light">sans-serif-light</string>
<string name="font_family_medium">sans-serif-medium</string>
<string name="font_family_regular">sans-serif</string>
<string name="font_family_condensed">sans-serif-condensed</string>
<string name="font_family_black">sans-serif-black</string>
<string name="font_family_thin">sans-serif-thin</string>
</resources>

Answer 6

Dinámicamente, puedes configurar la familia de fuentes similar a android: fontFamily en xml usando esto,

For Custom font:
TextView tv = ((TextView) v.findViewById(R.id.select_item_title));
Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf");
tv.setTypeface(face);
For Default font:
tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

Esta es la lista de la familia de fuentes predeterminada utilizada, use cualquiera de esto reemplazando la cadena de doble comillas "sans-serif-medium"

FONT FAMILY TTF FILE
1 casual ComingSoon.ttf
2 cursive DancingScript-Regular.ttf
3 monospace DroidSansMono.ttf
4 sans-serif Roboto-Regular.ttf
5 sans-serif-black Roboto-Black.ttf
6 sans-serif-condensed RobotoCondensed-Regular.ttf
7 sans-serif-condensed-light RobotoCondensed-Light.ttf
8 sans-serif-light Roboto-Light.ttf
9 sans-serif-medium Roboto-Medium.ttf
10 sans-serif-smallcaps CarroisGothicSC-Regular.ttf
11 sans-serif-thin Roboto-Thin.ttf
12 serif NotoSerif-Regular.ttf
13 serif-monospace CutiveMono.ttf

"mycustomfont.ttf" es el archivo ttf. La ruta estará en src / asset / fonts / mycustomfont.ttf , puede consultar más sobre la fuente predeterminada en esta familia de fuentes predeterminada

Answer 7

El valor válido de android: fontFamily se define en /system/etc/system_fonts.xml(4.x) o /system/etc/fonts.xml(5.x). Pero el fabricante del dispositivo puede modificarlo, por lo que la fuente real utilizada al configurar el valor de fontFamily depende del archivo mencionado anteriormente del dispositivo especificado.

En AOSP, la fuente Arial es válida pero debe definirse utilizando "arial" no "Arial", por ejemplo, android: fontFamily = "arial" . Echa un vistazo a qukik en system_fonts.xml de Kitkat

 <family>
<nameset>
<name>sans-serif</name>
<name>arial</name>
<name>helvetica</name>
<name>tahoma</name>
<name>verdana</name>
</nameset>
<fileset>
<file>Roboto-Regular.ttf</file>
<file>Roboto-Bold.ttf</file>
<file>Roboto-Italic.ttf</file>
<file>Roboto-BoldItalic.ttf</file>
</fileset>
</family>

////////////////////////////////////////////////// ////////////////////////////

Hay tres atributos xml relevantes para definir una "fuente" en el diseño : android: fontFamily , android: tipo de letra y android: textStyle . La combinación de "fontFamily" y "textStyle" o "tipografía" y "textStyle" se puede usar para cambiar la apariencia de la fuente en el texto, por lo que se usa solo. Fragmento de código en TextView.java como este:

 private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {
Typeface tf = null;
if (familyName != null) {
tf = Typeface.create(familyName, styleIndex);
if (tf != null) {
setTypeface(tf);
return;
}
}
switch (typefaceIndex) {
case SANS:
tf = Typeface.SANS_SERIF;
break;
case SERIF:
tf = Typeface.SERIF;
break;
case MONOSPACE:
tf = Typeface.MONOSPACE;
break;
}
setTypeface(tf, styleIndex);
}
public void setTypeface(Typeface tf, int style) {
if (style > 0) {
if (tf == null) {
tf = Typeface.defaultFromStyle(style);
} else {
tf = Typeface.create(tf, style);
}
setTypeface(tf);
// now compute what (if any) algorithmic styling is needed
int typefaceStyle = tf != null ? tf.getStyle() : 0;
int need = style & ~typefaceStyle;
mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);
mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);
} else {
mTextPaint.setFakeBoldText(false);
mTextPaint.setTextSkewX(0);
setTypeface(tf);
}
}

Desde el código podemos ver:

1. si se establece "fontFamily", se ignorará el "tipo de letra".
2. "Tipo de letra" tiene valores válidos estándar y limitados. De hecho, los valores son "normales" "sans", "serif" y "monoespacio", se pueden encontrar en system_fonts.xml (4.x) o fonts.xml (5.x). En realidad, tanto "normal" como "sans" son la fuente predeterminada del sistema.
3. "fontFamily" se puede usar para establecer todas las fuentes de fuentes incorporadas, mientras que "tipografía" solo proporciona las fuentes típicas de "sans-serif", "serif" y "monoespaciado" (las tres categorías principales de fuentes en el mundo) .
4. Cuando solo configuramos "textStyle", en realidad configuramos la fuente predeterminada y el estilo especificado. El valor efectivo es "normal", "negrita" y "negrita | cursiva".

Answer 8

Es lo mismo que android:typeface .

Las fuentes incorporadas son:

• normal
• sans
• serif
• monoespacio

Ver android:typeface .

Answer 9

Esta es la manera de establecer la fuente programáticamente:

TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
"fonts/epimodem.ttf");
tv.setTypeface(face);

ponga el archivo de fuente en su carpeta de activos. En mi caso creé un subdirectorio llamado fuentes.

EDITAR: Si se pregunta dónde está su carpeta de activos vea esta pregunta

Answer 10

Esta es también una buena biblioteca de RobotoTextView . Realmente sirve a sus necesidades.

Answer 11

Establece el estilo en res/layout/value/style.xml así:

<style name="boldText">
<item name="android:textStyle">bold|italic</item>
<item name="android:textColor">#FFFFFF</item>
</style>

y para usar este estilo en el uso del archivo main.xml :

style="@style/boldText"

Answer 12

Estoy usando una excelente biblioteca de Calligraphy de Chris Jenx, diseñada para permitirte usar fuentes personalizadas en tu aplicación de Android. ¡Darle una oportunidad!

Answer 13

Hice una pequeña biblioteca llamada Foundry que puede usar para aplicar tipos de letra personalizados a través de diseños y estilos XML.

Answer 14

Lo que quieres no es posible. Debe tener que establecer TypeFace en su Código.

En XML lo que puedes hacer es

android:typeface="sans" | "serif" | "monospace"

Aparte de esto no puedes jugar mucho con las fuentes en XML. :)

Para Arial necesitas configurar el tipo de letra en tu código.

Answer 15

Para configurar Roboto programáticamente:

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));

Answer 16

Prueba estos simples pasos. 1. crear la carpeta de fuentes en la carpeta res. 2. Copie y pegue el archivo .ttf en la carpeta de fuentes. 3. Ahora dale la ruta en xml como abajo.

 android:fontFamily="@font/frutiger"

o cualquiera que sea su nombre de archivo. Eso es código feliz

Answer 17

Puedes hacerlo de manera fácil usando la siguiente biblioteca

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerView
android:textStyle="bold"
android:text="@string/about_us"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingTop="8dp"
app:fontName="Lato-Bold"
android:textSize="18sp"
android:id="@+id/textView64" />

es ligero y fácil de implementar, solo copie sus fuentes en la carpeta de activos y use el nombre en xml.

Answer 18

Si desea utilizar un TextView en tantos lugares con la misma familia de fuentes, amplíe la clase TextView y configure su fuente de la siguiente manera:

public class ProximaNovaTextView extends TextView {
public ProximaNovaTextView(Context context) {
super(context);
applyCustomFont(context);
}
public ProximaNovaTextView(Context context, AttributeSet attrs) {
super(context, attrs);
applyCustomFont(context);
}
public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
applyCustomFont(context);
}
private void applyCustomFont(Context context) {
Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);
setTypeface(customFont);
}
}

Y luego use esta clase personalizada en xml para el TextView como este:

 <com.myapp.customview.ProximaNovaTextView
android:id="@+id/feed_list_item_name_tv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textSize="14sp"
/>

Answer 19

Si lo quieres programáticamente, puedes usar

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

Donde SANS_SERIF puedes usar:

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

Y donde puedes usar ITALIC :

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

Todo está indicado en los desarrolladores de Android

Answer 20

Solo quiero mencionar que el infierno con las fuentes dentro de Android está por terminar, porque este año en Google IO finalmente obtuvimos esto -> https://developer.android.com/preview/features/working-with-fonts. html

Ahora hay un nuevo tipo de recurso, una fuente, y puede colocar todas las fuentes de su aplicación dentro de la carpeta res / fonts y acceder luego a R.font.my_custom_font, al igual que puede acceder a los valores de res de cadena , valores de res de dibujo, etc. para crear el archivo xml font-face , que se configurará con sus fuentes personalizadas (en cursiva, negrita y subrayado).

Lea el enlace de arriba para más información. Veamos el soporte.

Answer 21

Tuve que analizar /system/etc/fonts.xml en un proyecto reciente. Aquí están las familias de fuentes actuales a partir de Lollipop:

╔════╦════════════════════════════╦═════════════════════════════╗
║ ║ FONT FAMILY ║ TTF FILE ║
╠════╬════════════════════════════╬═════════════════════════════╣
║ 1 ║ casual ║ ComingSoon.ttf ║
║ 2 ║ cursive ║ DancingScript-Regular.ttf ║
║ 3 ║ monospace ║ DroidSansMono.ttf ║
║ 4 ║ sans-serif ║ Roboto-Regular.ttf ║
║ 5 ║ sans-serif-black ║ Roboto-Black.ttf ║
║ 6 ║ sans-serif-condensed ║ RobotoCondensed-Regular.ttf ║
║ 7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf ║
║ 8 ║ sans-serif-light ║ Roboto-Light.ttf ║
║ 9 ║ sans-serif-medium ║ Roboto-Medium.ttf ║
║ 10 ║ sans-serif-smallcaps ║ CarroisGothicSC-Regular.ttf ║
║ 11 ║ sans-serif-thin ║ Roboto-Thin.ttf ║
║ 12 ║ serif ║ NotoSerif-Regular.ttf ║
║ 13 ║ serif-monospace ║ CutiveMono.ttf ║
╚════╩════════════════════════════╩═════════════════════════════╝

Aquí está el analizador (basado en FontListParser ):

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import android.util.Xml;
/**
* Helper class to get the current font families on an Android device.</p>
*
* Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>
*/
public final class FontListParser {
private static final File FONTS_XML = new File("/system/etc/fonts.xml");
private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");
public static List<SystemFont> getSystemFonts() throws Exception {
String fontsXml;
if (FONTS_XML.exists()) {
fontsXml = FONTS_XML.getAbsolutePath();
} else if (SYSTEM_FONTS_XML.exists()) {
fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();
} else {
throw new RuntimeException("fonts.xml does not exist on this system");
}
Config parser = parse(new FileInputStream(fontsXml));
List<SystemFont> fonts = new ArrayList<>();
for (Family family : parser.families) {
if (family.name != null) {
Font font = null;
for (Font f : family.fonts) {
font = f;
if (f.weight == 400) {
break;
}
}
SystemFont systemFont = new SystemFont(family.name, font.fontName);
if (fonts.contains(systemFont)) {
continue;
}
fonts.add(new SystemFont(family.name, font.fontName));
}
}
for (Alias alias : parser.aliases) {
if (alias.name == null || alias.toName == null || alias.weight == 0) {
continue;
}
for (Family family : parser.families) {
if (family.name == null || !family.name.equals(alias.toName)) {
continue;
}
for (Font font : family.fonts) {
if (font.weight == alias.weight) {
fonts.add(new SystemFont(alias.name, font.fontName));
break;
}
}
}
}
if (fonts.isEmpty()) {
throw new Exception("No system fonts found.");
}
Collections.sort(fonts, new Comparator<SystemFont>() {
@Override
public int compare(SystemFont font1, SystemFont font2) {
return font1.name.compareToIgnoreCase(font2.name);
}
});
return fonts;
}
public static List<SystemFont> safelyGetSystemFonts() {
try {
return getSystemFonts();
} catch (Exception e) {
String[][] defaultSystemFonts = {
{
"cursive", "DancingScript-Regular.ttf"
}, {
"monospace", "DroidSansMono.ttf"
}, {
"sans-serif", "Roboto-Regular.ttf"
}, {
"sans-serif-light", "Roboto-Light.ttf"
}, {
"sans-serif-medium", "Roboto-Medium.ttf"
}, {
"sans-serif-black", "Roboto-Black.ttf"
}, {
"sans-serif-condensed", "RobotoCondensed-Regular.ttf"
}, {
"sans-serif-thin", "Roboto-Thin.ttf"
}, {
"serif", "NotoSerif-Regular.ttf"
}
};
List<SystemFont> fonts = new ArrayList<>();
for (String[] names : defaultSystemFonts) {
File file = new File("/system/fonts", names[1]);
if (file.exists()) {
fonts.add(new SystemFont(names[0], file.getAbsolutePath()));
}
}
return fonts;
}
}
/* Parse fallback list (no names) */
public static Config parse(InputStream in) throws XmlPullParserException, IOException {
try {
XmlPullParser parser = Xml.newPullParser();
parser.setInput(in, null);
parser.nextTag();
return readFamilies(parser);
} finally {
in.close();
}
}
private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {
Alias alias = new Alias();
alias.name = parser.getAttributeValue(null, "name");
alias.toName = parser.getAttributeValue(null, "to");
String weightStr = parser.getAttributeValue(null, "weight");
if (weightStr == null) {
alias.weight = 0;
} else {
alias.weight = Integer.parseInt(weightStr);
}
skip(parser); // alias tag is empty, ignore any contents and consume end tag
return alias;
}
private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,
IOException {
Config config = new Config();
parser.require(XmlPullParser.START_TAG, null, "familyset");
while (parser.next() != XmlPullParser.END_TAG) {
if (parser.getEventType() != XmlPullParser.START_TAG) {
continue;
}
if (parser.getName().equals("family")) {
config.families.add(readFamily(parser));
} else if (parser.getName().equals("alias")) {
config.aliases.add(readAlias(parser));
} else {
skip(parser);
}
}
return config;
}
private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,
IOException {
String name = parser.getAttributeValue(null, "name");
String lang = parser.getAttributeValue(null, "lang");
String variant = parser.getAttributeValue(null, "variant");
List<Font> fonts = new ArrayList<Font>();
while (parser.next() != XmlPullParser.END_TAG) {
if (parser.getEventType() != XmlPullParser.START_TAG) {
continue;
}
String tag = parser.getName();
if (tag.equals("font")) {
String weightStr = parser.getAttributeValue(null, "weight");
int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);
boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));
String filename = parser.nextText();
String fullFilename = "/system/fonts/" + filename;
fonts.add(new Font(fullFilename, weight, isItalic));
} else {
skip(parser);
}
}
return new Family(name, fonts, lang, variant);
}
private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
int depth = 1;
while (depth > 0) {
switch (parser.next()) {
case XmlPullParser.START_TAG:
depth++;
break;
case XmlPullParser.END_TAG:
depth--;
break;
}
}
}
private FontListParser() {
}
public static class Alias {
public String name;
public String toName;
public int weight;
}
public static class Config {
public List<Alias> aliases;
public List<Family> families;
Config() {
families = new ArrayList<Family>();
aliases = new ArrayList<Alias>();
}
}
public static class Family {
public List<Font> fonts;
public String lang;
public String name;
public String variant;
public Family(String name, List<Font> fonts, String lang, String variant) {
this.name = name;
this.fonts = fonts;
this.lang = lang;
this.variant = variant;
}
}
public static class Font {
public String fontName;
public boolean isItalic;
public int weight;
Font(String fontName, int weight, boolean isItalic) {
this.fontName = fontName;
this.weight = weight;
this.isItalic = isItalic;
}
}
public static class SystemFont {
public String name;
public String path;
public SystemFont(String name, String path) {
this.name = name;
this.path = path;
}
}
}

Siéntase libre de utilizar la clase anterior en su proyecto. Por ejemplo, podría dar a sus usuarios una selección de familias de fuentes y establecer el tipo de letra según sus preferencias.

Un pequeño ejemplo incompleto:

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();
String[] items = new String[fonts.size()];
for (int i = 0; i < fonts.size(); i++) {
items[i] = fonts.get(i).name;
}
new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
FontListParser.SystemFont selectedFont = fonts.get(which);
// TODO: do something with the font
Toast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();
}
}).show();

Answer 22

Una forma fácil de administrar las fuentes sería declararlas a través de recursos, como tales:

<!--++++++++++++++++++++++++++-->
<!--added on API 16 (JB - 4.1)-->
<!--++++++++++++++++++++++++++-->
<!--the default font-->
<string name="fontFamily__roboto_regular">sans-serif</string>
<string name="fontFamily__roboto_light">sans-serif-light</string>
<string name="fontFamily__roboto_condensed">sans-serif-condensed</string>
<!--+++++++++++++++++++++++++++++-->
<!--added on API 17 (JBMR1 - 4.2)-->
<!--+++++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_thin">sans-serif-thin</string>
<!--+++++++++++++++++++++++++++-->
<!--added on Lollipop (LL- 5.0)-->
<!--+++++++++++++++++++++++++++-->
<string name="fontFamily__roboto_medium">sans-serif-medium</string>
<string name="fontFamily__roboto_black">sans-serif-black</string>
<string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

Esto se basa en el código fuente here y here

Answer 23

Here puede ver todos los valores disponibles de FontFamily y los nombres de los archivos de fuentes correspondientes (este archivo se usa en Android 5.0+). En dispositivo móvil, puedes encontrarlo en:

/system/etc/fonts.xml (para 5.0+)

(Para Android 4.4 y versiones posteriores que utilizan this versión, pero creo que fonts.xml tiene un formato más claro y fácil de entender).

Por ejemplo,

 <!-- first font is default -->
20 <family name="sans-serif">
21 <font weight="100" style="normal">Roboto-Thin.ttf</font>
22 <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>
23 <font weight="300" style="normal">Roboto-Light.ttf</font>
24 <font weight="300" style="italic">Roboto-LightItalic.ttf</font>
25 <font weight="400" style="normal">Roboto-Regular.ttf</font>
26 <font weight="400" style="italic">Roboto-Italic.ttf</font>
27 <font weight="500" style="normal">Roboto-Medium.ttf</font>
28 <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>
29 <font weight="900" style="normal">Roboto-Black.ttf</font>
30 <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>
31 <font weight="700" style="normal">Roboto-Bold.ttf</font>
32 <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>
33 </family>

El nombre de atributo name="sans-serif" de la etiqueta family definió el valor que puede usar en android: fontFamily.

La etiqueta de font define los archivos de fuente correspondientes.

En este caso, puede ignorar la fuente en <!-- fallback fonts --> , se usa para la lógica de respaldo de las fuentes.

Answer 24

Para Android Studio 3 y superior puede usar este estilo y luego todos los textViewcambios de fuente en la aplicación.

Crea este estilo en tu style.xml:

<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
<item name="android:fontFamily">@font/your_custom_font</item>
</style>

Entonces utilízalo en tu tema:

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
<!-- Customize your theme here. -->
<item name="colorPrimary">@color/colorPrimary</item>
<item name="colorPrimaryDark">@color/colorPrimaryDark</item>
<item name="colorAccent">@color/colorAccent</item>
<item name="android:textViewStyle">@style/defaultTextViewStyle</item>
</style>

Answer 25

Utilizo Letter Press lib para mis cosas NonTextView como Buttons y kianoni fontloader lib para mi TextViews. La causa del uso del estilo en esta biblioteca es más fácil que Letter Press para mí y tengo una respuesta ideal con eso. Esto es ideal para aquellos que quieren usar una fuente personalizada, excepto Roboto Font. Así fue mi experiencia con las librerías de fuentes. Para aquellos que quieran usar una clase personalizada para cambiar la fuente, recomiendo altamente crear esta clase con este fragmento de código.

 public class TypefaceSpan extends MetricAffectingSpan {
/** An <code>LruCache</code> for previously loaded typefaces. */
private static LruCache<String, Typeface> sTypefaceCache =
new LruCache<String, Typeface>(12);
private Typeface mTypeface;
/**
* Load the {@link android.graphics.Typeface} and apply to a {@link android.text.Spannable}.
*/
public TypefaceSpan(Context context, String typefaceName) {
mTypeface = sTypefaceCache.get(typefaceName);
if (mTypeface == null) {
mTypeface = Typeface.createFromAsset(context.getApplicationContext()
.getAssets(), String.format("fonts/%s", typefaceName));
// Cache the loaded Typeface
sTypefaceCache.put(typefaceName, mTypeface);
}
}
@Override
public void updateMeasureState(TextPaint p) {
p.setTypeface(mTypeface);
// Note: This flag is required for proper typeface rendering
p.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
}
@Override
public void updateDrawState(TextPaint tp) {
tp.setTypeface(mTypeface);
// Note: This flag is required for proper typeface rendering
tp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);
}
}

Y usa una clase como esta:

AppData = PreferenceManager.getDefaultSharedPreferences(this);
TextView bannertv= (TextView) findViewById(R.id.txtBanner);
SpannableString s = new SpannableString(getResources().getString(R.string.enterkey));
s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(),
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
bannertv.setText(s);

tal vez esta ayuda.

Answer 26

<string name="font_family_display_4_material">sans-serif-light</string>
<string name="font_family_display_3_material">sans-serif</string>
<string name="font_family_display_2_material">sans-serif</string>
<string name="font_family_display_1_material">sans-serif</string>
<string name="font_family_headline_material">sans-serif</string>
<string name="font_family_title_material">sans-serif-medium</string>
<string name="font_family_subhead_material">sans-serif</string>
<string name="font_family_menu_material">sans-serif</string>
<string name="font_family_body_2_material">sans-serif-medium</string>
<string name="font_family_body_1_material">sans-serif</string>
<string name="font_family_caption_material">sans-serif</string>
<string name="font_family_button_material">sans-serif-medium</string>