How to change fontFamily of TextView in 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

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

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

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.

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) 

To set Roboto programmatically:

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

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

It's the same as android:typeface.

built-in fonts are:

• normal
• sans
• serif
• monospace

See android:typeface.

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name); textView.setTypeface(typeface); 

set easily font to any textview from res>font directory programmatically

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

I think I am too late but maybe this solution helpful for others. For using a custom font place your font file in your font directory.

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato)); 

I am using the excellent library Calligraphy by Chris Jenx designed to allow you to use custom fonts in your android application. Give it a try!

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.

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> 

This is based on the source code here and here

If you are using Android Studio 3.5+, Changing the font is super simple. Select the text widget on the Design view and check the font family 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 the More Fonts option.

Attribute Window

Google Fonts

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

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"

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.

Try this:

TextView textview = (TextView) findViewById(R.id.textview); Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf"); textview .setTypeface(tf); 

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:

1. if "fontFamily" is set, then the "typeface" will be ignored.
2. "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.
3. "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).
4. When only set "textStyle", We actually set the default font and the specified style. The effective value are "normal" "bold" "italic" and "bold | italic".

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

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

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

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.

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.

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

The new font resource allows to directly set font using

android:fontFamily="@font/my_font_in_font_folder" 

For android-studio 3 and above you can use this style and then all textView font changes 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> 

If you want to use a TextView in so many places with the 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" />