Comment modifier la police de caractères dans TextView?
16 réponses
Premièrement, la valeur par défaut n'est pas Arial. La valeur par défaut est Droid Sans.
Deuxièmement, pour changer de police intégrée, utilisez android:typeface en XML ou setTypeface() en Java.
troisièmement, il n'y a pas de police Helvetica sur Android. Les choix intégrés sont Droid Sans ( sans ), Droid Sans Mono ( monospace ), et Droid Serif ( serif ). Alors que vous pouvez regrouper vos propres polices avec votre application et les utiliser via setTypeface() , bear in rappelez-vous que les fichiers de police sont volumineux et, dans certains cas, nécessitent des accords de licence (par exemple, Helvetica, une police de Linotype ).
MODIFIER
le langage de conception Android s'appuie sur les outils typographiques traditionnels comme l'échelle, l'espace, le rythme et l'alignement avec une grille sous-jacente. Le déploiement réussi de ces outils est essentiel pour aider les utilisateurs rapidement comprendre un écran d'information. Pour soutenir une telle utilisation typographie, Sandwich à la crème glacée a présenté un nouveau type de famille nommé Roboto, créé spécifiquement pour les exigences de L'UI et des écrans haute résolution.
le cadre TextView actuel offre à Roboto en mince, léger, régulier et gras, avec un style italique pour chaque poids. Le le cadre offre également la variante condensée de Roboto en régulier et en gras poids, avec un style italique pour chaque poids.
après ICS, android inclut Roboto fonts style, Lire la suite Roboto
EDIT 2
avec L'avènement de la bibliothèque de soutien 26, Android prend maintenant en charge les polices personnalisées par défaut. Vous pouvez insérer de nouvelles polices dans res / fonts qui peuvent être définies pour TextViews individuellement en XML ou programmatiquement. La police par défaut pour l'ensemble de la l'application peut aussi être changée en définissant des styles informatiques.xml la documentation du développeur android a un guide clair sur ce ici
téléchargez D'abord le fichier .ttf de la police dont vous avez besoin ( arial.ttf ). Placez-le dans le dossier assets . (À l'intérieur du dossier ACTIFS créer un nouveau dossier nommé polices et le placer à l'intérieur.) Utilisez le code suivant pour appliquer la police à votre TextView :
Typeface type = Typeface.createFromAsset(getAssets(),"fonts/arial.ttf");
textView.setTypeface(type);
Typeface tf = Typeface.createFromAsset(getAssets(),
"fonts/DroidSansFallback.ttf");
TextView tv = (TextView) findViewById(R.id.CustomFontText);
tv.setTypeface(tf);
, Vous pourriez vouloir créer classe statique qui contiendra toutes les polices. De cette façon, vous ne créerez pas la police plusieurs fois ce qui pourrait avoir un impact négatif sur performance . Assurez-vous de créer un sous-dossier appelé " polices "sous" actifs " le dossier.
faire quelque chose comme:
public class CustomFontsLoader {
public static final int FONT_NAME_1 = 0;
public static final int FONT_NAME_2 = 1;
public static final int FONT_NAME_3 = 2;
private static final int NUM_OF_CUSTOM_FONTS = 3;
private static boolean fontsLoaded = false;
private static Typeface[] fonts = new Typeface[3];
private static String[] fontPath = {
"fonts/FONT_NAME_1.ttf",
"fonts/FONT_NAME_2.ttf",
"fonts/FONT_NAME_3.ttf"
};
/**
* Returns a loaded custom font based on it's identifier.
*
* @param context - the current context
* @param fontIdentifier = the identifier of the requested font
*
* @return Typeface object of the requested font.
*/
public static Typeface getTypeface(Context context, int fontIdentifier) {
if (!fontsLoaded) {
loadFonts(context);
}
return fonts[fontIdentifier];
}
private static void loadFonts(Context context) {
for (int i = 0; i < NUM_OF_CUSTOM_FONTS; i++) {
fonts[i] = Typeface.createFromAsset(context.getAssets(), fontPath[i]);
}
fontsLoaded = true;
}
}
de Cette façon, vous pouvez obtenez la police de partout dans votre application.
Meilleure pratique
TextViewPlus.java:
public class TextViewPlus extends TextView {
private static final String TAG = "TextView";
public TextViewPlus(Context context) {
super(context);
}
public TextViewPlus(Context context, AttributeSet attrs) {
super(context, attrs);
setCustomFont(context, attrs);
}
public TextViewPlus(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
setCustomFont(context, attrs);
}
private void setCustomFont(Context ctx, AttributeSet attrs) {
TypedArray a = ctx.obtainStyledAttributes(attrs, R.styleable.TextViewPlus);
String customFont = a.getString(R.styleable.TextViewPlus_customFont);
setCustomFont(ctx, customFont);
a.recycle();
}
public boolean setCustomFont(Context ctx, String asset) {
Typeface typeface = null;
try {
typeface = Typeface.createFromAsset(ctx.getAssets(), asset);
} catch (Exception e) {
Log.e(TAG, "Unable to load typeface: "+e.getMessage());
return false;
}
setTypeface(typeface);
return true;
}
}
attrs.xml: (où placer res/values )
<?xml version="1.0" encoding="utf-8"?>
<resources>
<declare-styleable name="TextViewPlus">
<attr name="customFont" format="string"/>
</declare-styleable>
</resources>
comment utiliser:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:foo="http://schemas.android.com/apk/res-auto"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<com.mypackage.TextViewPlus
android:id="@+id/textViewPlus1"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:text="@string/showingOffTheNewTypeface"
foo:customFont="my_font_name_regular.otf">
</com.mypackage.TextViewPlus>
</LinearLayout>
espérons que cela vous aidera.
Les réponses ci-dessus sont correctes. Assurez-vous que vous créez un sous-dossier appelé "polices" à la rubrique "actifs" dossier si vous utilisez ce morceau de code.
une autre façon de consolider la création de polices...
public class Font {
public static final Font PROXIMA_NOVA = new Font("ProximaNovaRegular.otf");
public static final Font FRANKLIN_GOTHIC = new Font("FranklinGothicURWBoo.ttf");
private final String assetName;
private volatile Typeface typeface;
private Font(String assetName) {
this.assetName = assetName;
}
public void apply(Context context, TextView textView) {
if (typeface == null) {
synchronized (this) {
if (typeface == null) {
typeface = Typeface.createFromAsset(context.getAssets(), assetName);
}
}
}
textView.setTypeface(typeface);
}
}
et ensuite à utiliser dans votre activité...
myTextView = (TextView) findViewById(R.id.myTextView);
Font.PROXIMA_NOVA.apply(this, myTextView);
Attention, cet idiome de verrouillage double-vérifié avec le champ volatile ne fonctionne correctement qu'avec le modèle de mémoire utilisé en Java 1.5+.
meilleure pratique est D'utiliser Android Support Library version 26.0.0 ou supérieure.
étape 1: ajouter le fichier de police
- Dans res dossier de créer de nouveaux police dictionnaire de ressources
- Ajouter un fichier de police ( .ttf , .orf )
pour exemple, quand le fichier de police sera helvetica_neue.ttf qui génère R. de la police.helvetica_neue
étape 2: Créer une famille de polices
- Dans police dossier ajouter un nouveau fichier de ressources
- inclut chaque fichier de police, style et attribut de poids dans l'élément.
par exemple:
<?xml version="1.0" encoding="utf-8"?>
<font-family xmlns:android="http://schemas.android.com/apk/res/android">
<font
android:fontStyle="normal"
android:fontWeight="400"
android:font="@font/helvetica_neue" />
</font-family>
étape 3: utiliser
En xml dispositions:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:fontFamily="@font/my_font"/>
Ou ajouter des polices de style:
<style name="customfontstyle" parent="@android:style/TextAppearance.Small">
<item name="android:fontFamily">@font/lobster</item>
</style>
pour plus d'exemples, vous pouvez suivre la documentation:
c'est un peu vieux, mais j'ai amélioré un peu la classe CustomFontLoader et je voulais la partager pour qu'elle puisse être utile. Il suffit de créer une nouvelle classe avec ce code.
import android.content.Context;
import android.graphics.Typeface;
public enum FontLoader {
ARIAL("arial"),
TIMES("times"),
VERDANA("verdana"),
TREBUCHET("trbuchet"),
GEORGIA("georgia"),
GENEVA("geneva"),
SANS("sans"),
COURIER("courier"),
TAHOMA("tahoma"),
LUCIDA("lucida");
private final String name;
private Typeface typeFace;
private FontLoader(final String name) {
this.name = name;
typeFace=null;
}
public static Typeface getTypeFace(Context context,String name){
try {
FontLoader item=FontLoader.valueOf(name.toUpperCase(Locale.getDefault()));
if(item.typeFace==null){
item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");
}
return item.typeFace;
} catch (Exception e) {
return null;
}
}
public static Typeface getTypeFace(Context context,int id){
FontLoader myArray[]= FontLoader.values();
if(!(id<myArray.length)){
return null;
}
try {
if(myArray[id].typeFace==null){
myArray[id].typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+myArray[id].name+".ttf");
}
return myArray[id].typeFace;
}catch (Exception e) {
return null;
}
}
public static Typeface getTypeFaceByName(Context context,String name){
for(FontLoader item: FontLoader.values()){
if(name.equalsIgnoreCase(item.name)){
if(item.typeFace==null){
try{
item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");
}catch (Exception e) {
return null;
}
}
return item.typeFace;
}
}
return null;
}
public static void loadAllFonts(Context context){
for(FontLoader item: FontLoader.values()){
if(item.typeFace==null){
try{
item.typeFace=Typeface.createFromAsset(context.getAssets(), "fonts/"+item.name+".ttf");
}catch (Exception e) {
item.typeFace=null;
}
}
}
}
}
alors il suffit d'utiliser ce code sur vous textview:
Typeface typeFace=FontLoader.getTypeFace(context,"arial");
if(typeFace!=null) myTextView.setTypeface(typeFace);
import java.lang.ref.WeakReference;
import java.util.HashMap;
import android.content.Context;
import android.graphics.Typeface;
public class FontsManager {
private static FontsManager instance;
private static HashMap<String, WeakReference<Typeface>> typefaces = new HashMap<String, WeakReference<Typeface>>();
private static Context context;
private FontsManager(final Context ctx) {
if (context == null) {
context = ctx;
}
}
public static FontsManager getInstance(final Context appContext) {
if (instance == null) {
instance = new FontsManager(appContext);
}
return instance;
}
public static FontsManager getInstance() {
if (instance == null) {
throw new RuntimeException(
"Call getInstance(Context context) at least once to init the singleton properly");
}
return instance;
}
public Typeface getFont(final String assetName) {
final WeakReference<Typeface> tfReference = typefaces.get(assetName);
if (tfReference == null || tfReference.get() == null) {
final Typeface tf = Typeface.createFromAsset(context.getResources().getAssets(),
assetName);
typefaces.put(assetName, new WeakReference<Typeface>(tf));
return tf;
}
return tfReference.get();
}
}
de cette façon, vous pouvez créer une vue qui hérite de TextView et appelle setTypeface sur son constructeur.
obtenir de la police de l'actif et de régler tous les enfants
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(Typeface.createFromAsset(context.getAssets(),"DroidNaskh.ttf"));// "BKOODB.TTF"));
}
} catch (Exception e) {
}
}
- ajouter la classe FontTextView.java:
public class FontTextView extends TextView {
String fonts[] = {"HelveticaNeue.ttf", "HelveticaNeueLight.ttf", "motschcc.ttf", "symbol.ttf"};
public FontTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(attrs);
}
public FontTextView(Context context, AttributeSet attrs) {
super(context, attrs);
if (!isInEditMode()) {
init(attrs);
}
}
public FontTextView(Context context) {
super(context);
if (!isInEditMode()) {
init(null);
}
}
private void init(AttributeSet attrs) {
if (attrs != null) {
TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.FontTextView);
if (a.getString(R.styleable.FontTextView_font_type) != null) {
String fontName = fonts[Integer.valueOf(a.getString(R.styleable.FontTextView_font_type))];
if (fontName != null) {
Typeface myTypeface = Typeface.createFromAsset(getContext().getAssets(), "font/" + fontName);
setTypeface(myTypeface);
}
a.recycle();
}
}
}
}
- ajouter à la bibliothèque d'actifs de la police
-
ajouter à attrs.XML , Nombre devrait être dans l'ordre de la classe array.
<declare-styleable name="FontTextView"> <attr name="font_type" format="enum"> <enum name="HelveticaNeue" value="0"/> <enum name="HelveticaNeueLight" value="1"/> <enum name="motschcc" value="2"/> <enum name="symbol" value="3"/> </attr>
- sélectionner une police dans la liste
j'ai finalement obtenu une solution très facile à cela.
-
utilisez ces bibliothèques de soutien dans app level Grad ,
compile 'com.android.support:appcompat-v7:26.0.2' compile 'com.android.support:support-v4:26.0.2' -
ensuite créer un répertoire nommé "font " à l'intérieur du res dossier
- mettez les fichiers de polices (ttf) dans ce répertoire de polices, gardez à l'esprit les conventions de nommage [E. G. nom ne doit contenir aucun caractère spécial, aucun caractère majuscule et aucun espace ou onglet]
-
après cela, référence que la police de xml comme ceci
<Button android:id="@+id/btn_choose_employee" android:layout_width="140dp" android:layout_height="40dp" android:layout_centerInParent="true" android:background="@drawable/rounded_red_btn" android:onClick="btnEmployeeClickedAction" android:text="@string/searching_jobs" android:textAllCaps="false" android:textColor="@color/white" android:fontFamily="@font/times_new_roman_test" />
dans cet exemple, times_new_roman_test est une police de fichier ttf de ce répertoire de police
peut-être quelque chose d'un peu plus simple:
public class Fonts {
public static HashSet<String,Typeface> fonts = new HashSet<>();
public static Typeface get(Context context, String file) {
if (! fonts.contains(file)) {
synchronized (this) {
Typeface typeface = Typeface.createFromAsset(context.getAssets(), name);
fonts.put(name, typeface);
}
}
return fonts.get(file);
}
}
// Usage
Typeface myFont = Fonts.get("arial.ttf");
(notez que ce code n'a pas été testé, mais en général cette approche devrait bien fonctionner.)
lorsque votre police est stockée à l'intérieur de res/asset/fonts/Helvetica.ttf utilisez ce qui suit:
Typeface tf = Typeface.createFromAsset(getAssets(),"fonts/Helvetica.ttf");
txt.setTypeface(tf);
ou, si votre fichier de police est stocké à l'intérieur de res/font/helvetica.ttf utilisez ce qui suit:
Typeface tf = ResourcesCompat.getFont(this,R.font.helvetica);
txt.setTypeface(tf);
Android utilise la police Roboto, qui est une police vraiment jolie, avec plusieurs poids différents (régulier, léger, mince, condensé) qui semblent grands sur les écrans à haute densité.
Vérifier le lien ci-dessous pour vérifier roboto polices:
comment utiliser Roboto en format xml
retour à votre question, si vous voulez changer la police pour tout le TextView / bouton dans votre application , essayez ajout de code ci-dessous dans vos styles.xml à utiliser Roboto-lumière police:
<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<!-- Customize your theme here. -->
......
<item name="android:buttonStyle">@style/MyButton</item>
<item name="android:textViewStyle">@style/MyTextView</item>
</style>
<style name="MyButton" parent="@style/Widget.AppCompat.Button">
<item name="android:textAllCaps">false</item>
<item name="android:fontFamily">sans-serif-light</item>
</style>
<style name="MyTextView" parent="@style/TextAppearance.AppCompat">
<item name="android:fontFamily">sans-serif-light</item>
</style>
et n'oubliez pas d'utiliser "AppTheme" dans votre AndroidManifest.xml
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme">
......
</application>