How to change fontFamily of TextView in Android
AndroidAndroid LayoutTextviewTypefaceAndroid Problem Overview
So I'd like to change the android:fontFamily
in Android but I don't see any pre-defined fonts in Android. How do I select one of the pre-defined ones? I don't really need to define my own TypeFace but all I need is something different from what it shows right now.
<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"
/>
It seems what I did up there won't really work! BTW android:fontFamily="Arial"
was a stupid attempt!
Android Solutions
Solution 1 - Android
From android 4.1 / 4.2 / 5.0, the following Roboto font families are available:
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)
in combination with
android:textStyle="normal|bold|italic"
this 16 variants are possible:
- Roboto regular
- Roboto italic
- Roboto bold
- Roboto bold italic
- Roboto-Light
- Roboto-Light italic
- Roboto-Thin
- Roboto-Thin italic
- Roboto-Condensed
- Roboto-Condensed italic
- Roboto-Condensed bold
- Roboto-Condensed bold italic
- Roboto-Black
- Roboto-Black italic
- Roboto-Medium
- Roboto-Medium italic
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>
Solution 2 - Android
Starting from Android-Studio 3.0 its very easy to change font family
Using support library 26, it will work on devices running Android API version 16 and higher
Create a folder font
under res
directory .Download the font which ever you want and paste it inside font
folder. The structure should be some thing like below
Note: As of Android Support Library 26.0, you must declare both sets of attributes ( android: and app: ) to ensure your fonts load on devices running Api 26 or lower.
Now you can change font in layout using
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/dancing_script"
app:fontFamily="@font/dancing_script"/>
To change Programatically
Typeface typeface = getResources().getFont(R.font.myfont);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.myfont);
textView.setTypeface(typeface);
To change font using styles.xml create a style
<style name="Regular">
<item name="android:fontFamily">@font/dancing_script</item>
<item name="fontFamily">@font/dancing_script</item>
<item name="android:textStyle">normal</item>
</style>
and apply this style to TextView
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
style="@style/Regular"/>
you can also Create your own font family
- Right-click the font folder and go to New > Font resource file. The New Resource File window appears.
- Enter the file name, and then click OK. The new font resource XML opens in the editor.
Write your own font family here , for example
<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>
this is simply a mapping of a specific fontStyle and fontWeight to the font resource which will be used to render that specific variant. Valid values for fontStyle are normal or italic; and fontWeight conforms to the CSS font-weight specification
1. To change fontfamily in layout you can write
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/lobster"/>
2. To Change Programmatically
Typeface typeface = getResources().getFont(R.font.lobster);
//or to support all versions use
Typeface typeface = ResourcesCompat.getFont(context, R.font.lobster);
textView.setTypeface(typeface);
To change font of entire App Add these two lines in 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>
See the Documentation , Android Custom Fonts Tutorial For more info
Solution 3 - Android
This is the way to set the font programmatically:
TextView tv = (TextView) findViewById(R.id.appname);
Typeface face = Typeface.createFromAsset(getAssets(),
"fonts/epimodem.ttf");
tv.setTypeface(face);
put the font file in your assets folder. In my case I created a subdirectory called fonts.
EDIT: If you wonder where is your assets folder see this question
Solution 4 - Android
I had to parse /system/etc/fonts.xml
in a recent project. Here are the current font families as of 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 ║
╚════╩════════════════════════════╩═════════════════════════════╝
Here is the parser (based off 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;
}
}
}
Feel free to use the above class in your project. For example, you could give your users a selection of font families and set the typeface based on their preference.
A small incomplete example:
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();
Solution 5 - Android
Android doesn't allow you to set custom fonts from the XML layout. Instead, you must bundle the specific font file in your app's assets folder, and set it programmatically. Something like:
TextView textView = (TextView) findViewById(<your TextView ID>);
Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");
textView.setTypeface(typeFace);
Note that you can only run this code after setContentView() has been called. Also, only some fonts are supported by Android, and should be in a .ttf (TrueType)
or .otf (OpenType)
format. Even then, some fonts may not work.
This is a font that definitely works on Android, and you can use this to confirm that your code is working in case your font file isn't supported by Android.
Android O Update: This is now possible with XML in Android O, based on Roger's comment.
Solution 6 - Android
To set Roboto programmatically:
paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));
Solution 7 - Android
If you want it programatically, you could use
label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);
Where SANS_SERIF
you can use:
DEFAULT
DEFAULT_BOLD
MONOSPACE
SANS_SERIF
SERIF
And where ITALIC
you can use:
BOLD
BOLD_ITALIC
ITALIC
NORMAL
All is stated on Android Developers
Solution 8 - Android
Kotlin Code - Textview to set custom font from Resource Folder
Set custom font from res -> font -> avenir_next_regular.ttf
textView!!.typeface = ResourcesCompat.getFont(context!!, R.font.avenir_next_regular)
Solution 9 - Android
It's the same as android:typeface
.
built-in fonts are:
- normal
- sans
- serif
- monospace
See android:typeface.
Solution 10 - Android
One simple way is by adding the desired font in the project.
Go to File->New->New Resource Directory Select font
This will create a new directory, font, in your resources.
Download your font (.ttf). I use https://fonts.google.com for the same
Add that to your fonts folder then use them in the XML or programmatically.
XML -
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/your_font"/>
Programatically -
Typeface typeface = ResourcesCompat.getFont(this, R.font.your_font);
textView.setTypeface(typeface);
Solution 11 - Android
Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);
textView.setTypeface(typeface);
set easily font to any textview from res>font directory programmatically
Solution 12 - Android
I think I am too late but maybe this solution helpful for others. For using custom font place your font file in your font directory.
textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));
Solution 13 - Android
I am using excellent library Calligraphy by Chris Jenx designed to allow you to use custom fonts in your android application. Give it a try!
Solution 14 - Android
What you want is not possible. You must need to set TypeFace
in your Code.
In XML
what you can do is
android:typeface="sans" | "serif" | "monospace"
other then this you can not play much with the Fonts in XML. :)
For Arial
you need to set type face in your code.
Solution 15 - Android
An easy way to manage the fonts would be to declare them via resources, as such:
<!--++++++++++++++++++++++++++-->
<!--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>
Solution 16 - Android
Dynamically you can set the fontfamily similar to android:fontFamily in xml by using this,
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));
These are the list of default font family used, use any of this by replacing the double quotation string "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" is the ttf file. Path will be in src/assets/fonts/mycustomfont.ttf , you can refer more about default font in this Default font family
Solution 17 - Android
If you are using Android Studio 3.5+, Changing font is super simple. Select the text widget on Design view and check fontFamily on Attribute Window. The value dropdown contains all the available fonts from which you can select one. If you are looking for Google Fonts, Click More Fonts option.
Solution 18 - Android
You can also do this by adding a font folder under the res directory like below.
Then, selecting Font as the resource type.
You can find avaliable fonts from https://www.1001fonts.com/, and then extracting the TTF files to this font directory.
Finally, just change the XML file that contains your textview by adding android:fontFamily:"@font/urfontfilename"
Solution 19 - Android
With some trial and error I learned the following.
Within the *.xml you can combine the stock fonts with the following functions, not only with typeface:
android:fontFamily="serif"
android:textStyle="italic"
With this two styles, there was no need to use typeface in any other case. The range of combinations is much more bigger with fontfamily&textStyle.
Solution 20 - Android
The valid value of android:fontFamily is defined in /system/etc/system_fonts.xml(4.x) or /system/etc/fonts.xml(5.x). But Device Manufacturer might modify it, so the actual font used by setting fontFamily value depends on the above-mentioned file of the specified device.
In AOSP, the Arial font is valid but must be defined using "arial" not "Arial", for example android:fontFamily="arial". Have a qucik look at Kitkat's system_fonts.xml
<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>
//////////////////////////////////////////////////////////////////////////
There are three relevant xml-attributes for defining a "font" in layout--android:fontFamily, android:typeface and android:textStyle. The combination of "fontFamily" and "textStyle" or "typeface" and "textStyle" can be used to change the appearance of font in text, so does used alone. Code snippet in TextView.java like this:
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);
}
}
From the code We can see:
- if "fontFamily" is set, then the "typeface" will be ignored.
- "typeface" has standard and limited valid values. In fact, the values are "normal" "sans" "serif" and "monospace", they can be found in system_fonts.xml(4.x) or fonts.xml(5.x). Actually both "normal" and "sans" are the default font of system.
- "fontFamily" can be used to set all fonts of build-in fonts, while "typeface" only provide the typical fonts of "sans-serif" "serif" and "monospace"(the three main category of font type in the world).
- When only set "textStyle", We actually set the default font and the specified style. The effective value are "normal" "bold" "italic" and "bold | italic".
Solution 21 - Android
Try this:
TextView textview = (TextView) findViewById(R.id.textview);
Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");
textview .setTypeface(tf);
Solution 22 - Android
Here is an easier way that can work in some cases. The principle is to add a not visible TextVview in your xml layout and to get its typeFace in the java code.
The layout in the xml file:
<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"/>
And the java code:
myText.setTypeface(textViewSelectedDescription.getTypeface());
It has worked for me (within a TextSwitcher for example).
Solution 23 - Android
To set the font by program, write...
TextView tv7 = new TextView(this);
tv7.setText(" TIME ");
tv7.setTypeface(Typeface.create("sans-serif-condensed",Typeface.BOLD));
tv7.setTextSize(12);
tbrow.addView(tv7);
The name "sans-serif-condensed" is referenced from fonts.xml file which should be created in app--> res--> values folder and it holds the fonts in it.
<?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>
Hope this is clear!
Solution 24 - Android
<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>
Solution 25 - Android
If you want to use a TextView in so many places with same font family, extend the TextView class and set your font like this:-
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);
}
}
And then use this custom class in xml for the TextView like this:-
<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"
/>
Solution 26 - Android
I just want to mention that the hell with the fonts inside Android is about to end, because this year on Google IO we finally got this -> https://developer.android.com/preview/features/working-with-fonts.html
Now there is a new resource type a font and you can place all your application fonts inside res/fonts folder and access then with R.font.my_custom_font, just like you can access string res values, drawable res values etc. You have even chance to create font-face xml file, which is gonna be set of your custom fonts (about italic, bold and underline attr).
Read the link above for more info. Let's see the support.
Solution 27 - Android
The new font resource allows to directly set font
using
android:fontFamily="@font/my_font_in_font_folder"
Solution 28 - Android
You can define a custom FontFamily like this:
/res/font/usual.xml
:
<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:tools="http://schemas.android.com/tools"
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
tools:ignore="UnusedAttribute">
<font
android:fontStyle="normal"
android:fontWeight="200"
android:font="@font/usual_regular"
app:fontStyle="normal"
app:fontWeight="200"
app:font="@font/usual_regular" />
<font
android:fontStyle="italic"
android:fontWeight="200"
android:font="@font/usual_regular_italic"
app:fontStyle="italic"
app:fontWeight="200"
app:font="@font/usual_regular_italic" />
<font
android:fontStyle="normal"
android:fontWeight="600"
android:font="@font/usual_bold"
app:fontStyle="normal"
app:fontWeight="600"
app:font="@font/usual_bold" />
<font
android:fontStyle="italic"
android:fontWeight="600"
android:font="@font/usual_bold_italic"
app:fontStyle="italic"
app:fontWeight="600"
app:font="@font/usual_bold_italic" />
</font-family>
Now you can do
android:fontFamily="@font/usual"
Assuming your other font
resources are there as well, with lowercase letters and _
s.
Solution 29 - Android
You set style in res/layout/value/style.xml
like that:
<style name="boldText">
<item name="android:textStyle">bold|italic</item>
<item name="android:textColor">#FFFFFF</item>
</style>
and to use this style in main.xml
file use:
style="@style/boldText"
Solution 30 - Android
For android-studio 3 and above you can use this style and then all textView
font change in app.
create this style in your style.xml
:
<!--OverRide all textView font-->
<style name="defaultTextViewStyle" parent="android:Widget.TextView">
<item name="android:fontFamily">@font/your_custom_font</item>
</style>
Then use it in your theme :
<!-- 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>
Solution 31 - Android
The easiest way to add the font programatically to a TextView is to, first, add the font file in your Assets folder in the project. For example your font path is looking like this: assets/fonts/my_font.otf
And add it to a TextView as:
Kotlin
val font_path = "fonts/my_font.otf"
myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.typeface = myTypeface
Java
String font_path = "fonts/my_font.otf";
Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.setTypeface(myTypeface);
Solution 32 - Android
There is a nice library available for this
implementation 'uk.co.chrisjenx:calligraphy:2.3.0'
Solution 33 - Android
You can also change standard fonts with setTextAppearance
(requires API 16), see https://stackoverflow.com/a/36301508/2914140:
<style name="styleA">
<item name="android:fontFamily">sans-serif</item>
<item name="android:textStyle">bold</item>
<item name="android:textColor">?android:attr/textColorPrimary</item>
</style>
<style name="styleB">
<item name="android:fontFamily">sans-serif-light</item>
<item name="android:textStyle">normal</item>
<item name="android:textColor">?android:attr/textColorTertiary</item>
</style>
if(condition){
TextViewCompat.setTextAppearance(textView, R.style.styleA);
} else {
TextViewCompat.setTextAppearance(textView,R.style.styleB);
}
Solution 34 - Android
Probably my comment will be useful for somebody: I was trying to realize why app:fontFamily="@font/my_font"
doesn't work and after wasting some time found that working solution is android:fontFamily="@font/my_font"
Solution 35 - Android
Here you can see all the avaliable fontFamily values and it's corresponding font file's names(This file is using in android 5.0+). In mobile device, you can find it in:
> /system/etc/fonts.xml (for 5.0+)
(For android 4.4 and below using this version, but I think that fonts.xml
has a more clear format and easy to understand.)
For example,
<!-- 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>
The name attribute name="sans-serif"
of family
tag defined the value you can use in android:fontFamily.
The font
tag define the corresponded font files.
In this case, you can ignore the source under <!-- fallback fonts -->
, it's using for fonts' fallback logic.
Solution 36 - Android
I use Letter Press lib for my NonTextView stuff like Buttons and kianoni fontloader lib for my TextViews cause of usage of style in this lib is more easy than Letter Press for me and i got ideal feedback with that. this is great for those who want to use custom font except Roboto Font. so it was my experience with font libs. for those who want to use custom class for change font i highly recommended to create this class with this snippet
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);
}
}
And use class like this :
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);
maybe this help.
Solution 37 - Android
You can do it easy way by using following library
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" />
its light weight and easy to implement, just copy your fonts in asset folder and use name in xml.
Solution 38 - Android
try these simple steps.
-
create font folder in res folder.
-
copy and paste .ttf file into font folder.
-
Now give the path in xml like below.
android:fontFamily="@font/frutiger" or what ever your file name is. Thats it happy code
Solution 39 - Android
<?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"
xmlns:tools="http://schemas.android.com/tools"
tools:ignore="UnusedAttribute">
<font
android:font="@font/google_sans_regular"
android:fontStyle="normal"
android:fontWeight="400"
app:font="@font/google_sans_regular"
app:fontStyle="normal"
app:fontWeight="400" />
<font
android:font="@font/google_sans_italic"
android:fontStyle="italic"
android:fontWeight="400"
app:font="@font/google_sans_italic"
app:fontStyle="italic"
app:fontWeight="400" />
<font
android:font="@font/google_sans_medium"
android:fontStyle="normal"
android:fontWeight="500"
app:font="@font/google_sans_medium"
app:fontStyle="normal"
app:fontWeight="500" />
<font
android:font="@font/google_sans_medium_italic"
android:fontStyle="italic"
android:fontWeight="500"
app:font="@font/google_sans_medium_italic"
app:fontStyle="italic"
app:fontWeight="500" />
<font
android:font="@font/google_sans_bold"
android:fontStyle="normal"
android:fontWeight="600"
app:font="@font/google_sans_bold"
app:fontStyle="normal"
app:fontWeight="600" />
<font
android:font="@font/google_sans_bold_italic"
android:fontStyle="italic"
android:fontWeight="600"
app:font="@font/google_sans_bold_italic"
app:fontStyle="italic"
app:fontWeight="600" />
</font-family>