Ajouter des polices personnalisées pour compléter application android

Dans vos activités, à droite après l'appel de

setContentView(R. id.blahblah);

vous devez exécuter une méthode pour aller sur l'ensemble de la hiérarchie des widgets et de les traiter avec la substitution de polices, comme;

setContentView(R.id.blahblah);
Utils.overrideFonts(this, findViewById(android.R.id.content));

Et le dit "overrideFonts" méthode doit être quelque chose comme;

public static void overrideFonts(final Context context, final View v) {
    try {
        if (v instanceof ViewGroup) {
            ViewGroup vg = (ViewGroup) v;
            for (int i = 0; i < vg.getChildCount(); i++) {
                View child = vg.getChildAt(i);
                overrideFonts(context, child);
            }
        } else if (v instanceof TextView) {
            ((TextView)v).setTypeface(FONT_REGULAR);
        }
    } catch (Exception e) {
        e.printStackTrace();
        //ignore
    }
}

Dans ce schéma, FONT_REGULAR doit être initialisé quelque part en toute sécurité, vous pouvez vous envie d'un singleton ou de quelque autre façon à s'assurer qu'il est correctement initialisé...

private static void initializeFonts(final Context context) {
    FONT_REGULAR = Typeface.createFromAsset(context.getAssets(), "fonts/myfont_medium.otf");
    FONT_BOLD = Typeface.createFromAsset(context.getAssets(), "fonts/myfont_bold.otf");
}

Si vous utilisez une sous-classe de l'Activité comme MyAppActivity (s'étend de l'Activité), alors vous n'avez pas besoin de modifier chaque classe d'Activité pour ces personnalisations. Au lieu de cela, vous pouvez couper et remplacer le comportement en tant que tel;

public class MyAppActivity extends Activity {
... ...
    @Override
    public void setContentView(final int layoutResID) {
        super.setContentView(layoutResID);
        Utils.overrideFonts(this, findViewById(android.R.id.content));
    }
... ...
}

De cette façon, vous pouvez utiliser n'importe quelle activité de la vôtre d'avoir un comportement commun;

public class SettingsUI extends MyAppActivity {
... ...
} 

J'espère que ça aide...
Cheers!

D'appliquer des polices personnalisées pour toutes les applications, il suffit de créer ou plusieurs des activités suivantes:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    FontManager.getInstance().initialize(this, R.xml.fonts);
    setContentView(R.layout.main);
}
@Override
public View onCreateView(String name, Context context, AttributeSet attrs) {
    SimpleFactory factory = new SimpleFactory();
    return factory.onCreateView(name, context, attrs);
}

où FontManager c'est la classe que gérer toutes les Polices que défini dans /xml/fonts.xml et SimpleFactory juste usine de créer des vues et d'appliquer des polices personnalisées pour chaque point de vue que l'exemple de l'affichage de texte.

/xml/fonts.xml

<?xml version="1.0" encoding="utf-8"?>
<familyset>
    <family>
        <nameset>
            <!--Font name-->
            <name>HelveticaNeueLTStd</name>
        </nameset>
        <fileset>
            <!--Font styles-->
            <file style="normal">fonts/HelveticaNeueLTStd-LtCn.otf</file>
            <file style="bold">fonts/HelveticaNeueLTStd-MdCn.otf</file>
            <file style="italic">fonts/HelveticaNeueLTStd-LtCnO.otf</file>
            <file style="bold_italic">fonts/HelveticaNeueLTStd-MdCnO.otf</file>
        </fileset>
    </family>
    <family>
        <!--There new font family can be added,
don't forget add font files into /assets/fonts directory and
put the name of the font into /values/string/font.xml-->
    </family>
</familyset>

FontFactory - abastract classe, juste étend à créer votre propre usine

public abstract class FontFactory implements LayoutInflater.Factory{
public final String TAG = getClass().getSimpleName();
static final Class<?>[] mConstructorSignature = new Class[] {Context.class, AttributeSet.class};
final Object[] mConstructorArgs = new Object[2];
private static final String[] sClassPrefixList = {
"android.widget.",
"android.webkit."
};
@Override
public View onCreateView(String name, Context context, AttributeSet attrs) {
if("ViewStub".equals(name) || "View".equals(name)){
return null;
}
View view = null;
Constructor<? extends View> constructor = null;
Class clazz = null;
if (view == null) {
if (-1 == name.indexOf('.')) {
for (String prefix : sClassPrefixList) {
clazz = getClazz(prefix, name);
if(clazz != null){
break;
}
}
} else {
clazz = getClazz("", name);
}
}
if (clazz == null) {
Log.d(TAG, "View can't be created " + name);
return null;
}
try {
constructor = clazz.getConstructor(mConstructorSignature);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
Object[] args = mConstructorArgs;
args[1] = attrs;
if(constructor == null){
return null;
}
try {
view = constructor.newInstance(context, attrs);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
if(view != null){
onFontApply(context, view);
}
return view;
}
public abstract void onFontApply(Context context, View view);
private Class getClazz(String prefix, String name){
Class clazz = null;
try {
clazz = Class.forName(prefix + name);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
return clazz;
}
}
}

FontManager - associez des fichiers de police définie dans /xml/fonts.xml pour les fichiers de police placés dans /assets et le retour de Caractères par nom de famille de polices et le style de police.

public void initialize(Context context, int resId) {
if(mFonts != null){
Log.d(TAG,"FontManager have already initialized");
return;
}
XmlResourceParser parser = null;
try {
parser = context.getResources().getXml(resId);
mFonts = new ArrayList<Font>();
String tag;
String fontStryleAttr = null;
int eventType = parser.getEventType();
Font font = null;
do {
tag = parser.getName();
switch (eventType) {
case XmlPullParser.START_TAG:
if (tag.equals(TAG_FAMILY)) {
//one of the font-families.
font = new Font();
} else if (tag.equals(TAG_NAMESET)) {
//a list of font-family names supported.
font.families = new ArrayList<String>();
} else if (tag.equals(TAG_NAME)) {
isName = true;
} else if (tag.equals(TAG_FILESET)) {
//a list of files specifying the different styles.
font.styles = new ArrayList<FontStyle>();
} else if (tag.equals(TAG_FILE)) {
isFile = true;
fontStryleAttr = parser.getAttributeValue(null, ATTR_STYLE);
}
break;
case XmlPullParser.END_TAG:
if (tag.equals(TAG_FAMILY)) {
//add it to the list.
if (font != null) {
mFonts.add(font);
font = null;
}
} else if (tag.equals(TAG_NAME)) {
isName = false;
} else if (tag.equals(TAG_FILE)) {
isFile = false;
fontStryleAttr = null;
}
break;
case XmlPullParser.TEXT:
String text = parser.getText();
if (isName) {
//value is a name, add it to list of family-names.
if (font.families != null)
font.families.add(text);
} else if (isFile) {
//value is a file, add it to the proper kind.
FontStyle fontStyle = new FontStyle();
fontStyle.font = Typeface.createFromAsset(context.getAssets(), text);
String attr = parser.getAttributeValue(null, ATTR_STYLE);
if (fontStryleAttr.equals(STYLE_BOLD))
fontStyle.style = Typeface.BOLD;
else if (fontStryleAttr.equals(STYLE_ITALIC))
fontStyle.style = Typeface.ITALIC;
else if (fontStryleAttr.equals(STYLE_BOLD_ITALIC))
fontStyle.style = Typeface.BOLD_ITALIC;
else
fontStyle.style = Typeface.NORMAL;
font.styles.add(fontStyle);
}
}
eventType = parser.next();
} while (eventType != XmlPullParser.END_DOCUMENT);
} catch (XmlPullParserException e) {
throw new InflateException("Error inflating font XML", e);
} catch (IOException e) {
throw new InflateException("Error inflating font XML", e);
} finally {
if (parser != null)
parser.close();
}
}
public Typeface get(String family, int style) {
for (Font font: mFonts) {
for (String familyName : font.families) {
if (familyName.equals(family)) {
//if no style in specified, return normal style.
if (style == -1)
style = Typeface.NORMAL;
for (FontStyle fontStyle : font.styles) {
if (fontStyle.style == style)
return fontStyle.font;
}
}
}
}
return mDefaultFont;
}

pour plus de code et des échantillons, il suffit de regarder ici

Vous pouvez utiliser PixlUI à http://bit.ly/1bzjWQn

importer leurs .jar dans votre projet. Utiliser XML

 <com.neopixl.pixlui.components.textview.TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world"
pixlui:typeface="MyFont.ttf" />

N'oubliez pas de mettre en œuvre le schéma ( xmlns:pixlui="http://schemas.android.com/apk/com.neopixl.pixlui" )

import android.content.Context;
import android.graphics.Typeface;
/**
* Created by Sanjeev Kumar on 4/18/2017.
*/
public class FontManager {
public Context mContext;
public FontManager(Context context) {
this.mContext = context;
}
public Typeface getSquarkiFont() {
return Typeface.createFromAsset(mContext.getAssets(), "fonts/Squarki.ttf");
}
public Typeface getLazySpringDayFont() {
return Typeface.createFromAsset(mContext.getAssets(), "fonts/LazySpringDay.ttf");
}
}