Typeface — ano ito, mga uri ng font at pagtatrabaho sa Android

Ano ang Typeface?

Typeface — ay isang Android class na nag-eencapsulate ng impormasyon tungkol sa font: pamilya nito (Roboto, Arial, Serif) at mga modifier ng estilo (kapal, italic). Hindi tulad ng UIFont sa iOS, ang Typeface ay hindi naglalaman ng impormasyon tungkol sa laki — ang laki ng text ay itinatakda nang hiwalay sa pamamagitan ng property na textSize sa TextView o TextStyle sa Spannable. Ang Typeface ay responsable lamang para sa anyo at garnitür ng font.

Ang klase ay magagamit sa lahat ng antas ng API. Hanggang Android 4.4, ang Typeface ay sumusuporta lamang sa limitadong hanay ng mga system font: DEFAULT, DEFAULT_BOLD, MONOSPACE, SERIF, SANS_SERIF. Simula sa Android 8.0 (API 26) ay idinagdag ang suporta para sa pag-load ng mga custom na font sa pamamagitan ng XML resources, at ang Android 10 ay nagdagdag ng suporta para sa mga variable font.

Mga built-in na Typeface constant

Ang Android ay nagbibigay ng ilang built-in na Typeface instance: Typeface.DEFAULT — system font na Roboto (Material) o Noto (AOSP), DEFAULT_BOLD — makapal na bersyon, MONOSPACE — monospace font para sa code, SERIF — font na may serif (Noto Serif), SANS_SERIF — sans-serif font (Noto Sans). Ang mga constant na ito ay magagamit nang walang konteksto at hindi nangangailangan ng pahintulot sa pagbasa ng file.

Typeface sa system

Ginagamit ng Android system ang Typeface para sa pag-render ng lahat ng text, kabilang ang system UI, mga heading, label, at notification. Bawat application ay maaaring mag-override ng default na font sa pamamagitan ng tema (android:fontFamily) o programmatically sa pamamagitan ng setTypeface(). Ang Typeface ay inilalapat sa lahat ng component na nagmana mula sa TextView: mga button, EditText, at custom na view.

Paglikha ng Typeface mula sa resources

Ang Android 8.0+ ay nagpapahintulot ng pagdagdag ng font sa res/font at paggamit ng mga ito sa pamamagitan ng XML resources. Ang file ng font (TTF o OTF) ay inilalagay sa res/font, pagkatapos ay nilikha ang reference na R.font.font_name. Ang Typeface ay nilo-load sa pamamagitan ng ResourcesCompat.getFont(context, R.font.font_name). Ang paraang ito ay mas pinipili dahil ang font ay naka-compile sa APK at sumusuporta sa ProGuard layout system.

Ang paraang resource ay sumusuporta din sa pamilya ng font (font family) sa pamamagitan ng XML file sa res/font: maaaring tukuyin ang maraming file para sa iba’t ibang anyo (regular, bold, italic) at awtomatikong pipili ang system ng tamang file sa pagtawag ng setTypeface. Pinapasimple nito ang tipograpiya — sapat na itakda ang fontFamily sa tema, at pipili ang Android ng tamang file.

Paglikha ng Typeface.create

Ang method na Typeface.create(Typeface family, int style) ay gumagawa ng font instance na may tinukoy na pamilya at estilo. Kung ang pamilya ay mayroon nang hiniling na estilo, ibabalik ang umiiral na instance. Kung wala ang estilo, ito ay ni-synthesize ng Android — naglalapat ng pekeng kapal o artipisyal na italic sa base font.

val boldTypeface = Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD)
val italicTypeface = Typeface.create(Typeface.MONOSPACE, Typeface.ITALIC)
val customTypeface = ResourcesCompat.getFont(context, R.font.montserrat_regular)
textView.typeface = boldTypeface

Ang na-synthesize na pseudo-bold ay maaaring magmukhang mababa ang kalidad sa manipis na font. Para sa mas mahusay na resulta, gumamit ng font file na may tunay na bold na anyo. Ang Typeface.create() na may hindi umiiral na estilo ay hindi nagtatapon ng exception, kundi bumabalik ng pinakamalapit na available na variant.

Typeface mula sa file at assets

Para sa pag-load ng Typeface mula sa assets ginagamit ang Typeface.createFromAsset(assetManager, path). Ang font ay inilalagay sa direktoryo na src/main/assets/fonts/, at ang path ay tinutukoy kaugnay sa assets. Ang paraang ito ay gumagana sa lahat ng bersyon ng Android, ngunit hindi sumusuporta sa pamilya ng font at nangangailangan ng pagtukoy ng partikular na file para sa bawat anyo.

Ang method na Typeface.createFromFile(File) ay naglo-load ng font mula sa anumang file sa file system. Ito ay kapaki-pakinabang para sa mga font na na-download mula sa network o kinopya sa panloob na storage ng application. Ang createFromFile ay hindi rin nangangailangan ng konteksto, na maginhawa para sa mga background task, ngunit ang file ay dapat na nababasa.

Pag-load mula sa assets na may caching

Ang paulit-ulit na pag-load ng Typeface mula sa assets sa pamamagitan ng createFromAsset ay maaaring humantong sa paglikha ng mga duplicate na object. Bawat tawag sa createFromAsset ay naglo-load muli ng file. Inirerekomenda na magpatupad ng Typeface cache sa pamamagitan ng HashMap, kung saan ang susi ay path ng file at ang halaga ay ang naka-load na instance. Ito ay lalong mahalaga para sa mga listahan na may iba’t ibang uri ng font.

object TypefaceCache {
    private val cache = mutableMapOf<String, Typeface>()
    fun getTypeface(context: Context, filename: String): Typeface {
        return cache.getOrPut(filename) {
            Typeface.createFromAsset(context.assets, "fonts/$filename")
        }
    }
}
// Paggamit
val typeface = TypefaceCache.getTypeface(context, "Roboto-Bold.ttf")

Ang cache sa memorya ay ginagarantiyahan na ang isang font ay na-load isang beses lamang bawat session ng application. Sa pagbabago ng configuration (pag-ikot ng screen), ang cache ay nananatili dahil ito ay nasa companion object. Para sa paglilinis ng cache kapag kulang ang memorya, gamitin ang WeakHashMap o makinig sa onTrimMemory.

Paglalapat ng Typeface sa TextView

Ang Typeface ay inilalapat sa TextView sa pamamagitan ng method na setTypeface(Typeface tf) o setTypeface(Typeface tf, int style). Ang pangalawang variant ay nagpapahintulot na baguhin ang estilo (bold/italic) kaugnay sa kasalukuyang font. Sa XML, ginagamit ang attribute na android:fontFamily na may reference sa font o system family. Para sa programmatic na setting, ang tawag na setTypeface(monospaceTypeface) ay papalitan ang font sa tinukoy.

Ang Typeface ay nakakaapekto sa buong text ng TextView. Kung kailangan ang ibang font sa isang linya, ginagamit ang SpannableString na may TypefaceSpan. Ang TypefaceSpan ay tumatanggap ng Typeface o family at inilalapat sa range ng mga character. Ito ang tanging paraan upang paghaluin ang mga font sa loob ng isang TextView nang walang nested component.

TypefaceSpan para sa bahagi ng text

Ilapat ang TypefaceSpan lamang sa bahagi ng string. Halimbawa, ang halaga ng variable sa text ay dapat ipakita gamit ang monospace font, at ang natitirang text ay gamit ang system font. Gumawa ng SpannableString, at sa nais na range ay itakda ang TypefaceSpan na may MONOSPACE Typeface. Ang natitirang text ay mananatili sa orihinal na font ng TextView.

val text = "Code: variableName"
val spannable = SpannableString(text)
spannable.setSpan(
    TypefaceSpan(Typeface.MONOSPACE),
    5, text.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
spannable.setSpan(
    ForegroundColorSpan(Color.BLUE),
    5, text.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
)
textView.text = spannable

Ang text na “variableName” ay ipapakita sa monospace font na kulay asul, at ang salitang “Kod:” ay mananatili sa system font. Ang TypefaceSpan ay maaaring pagsamahin sa anumang iba pang span para sa tumpak na kontrol sa bawat bahagi ng text.

Mga custom na font sa pamamagitan ng Typeface

Sinusuportahan ng Android ang ilang format ng font: TrueType (TTF), OpenType (OTF) at Web Open Font Format (WOFF2) simula Android 10. Ang TTF at OTF ay mga pangunahing format para sa custom na font. Ang XML font (Font Family) ay hindi hiwalay na format, kundi nagsisilbing deskripsyon kung aling file ang gagamitin para sa bawat anyo.

Para sa paggamit ng custom na font sa pamamagitan ng res/font gumawa ng XML family file kung saan tinutukoy ang mga path sa font file para sa regular, bold at italic. Pagkatapos sa tema ng application, itakda ang android:fontFamily="@font/custom_family". Lahat ng TextView na gumagamit ng temang ito ay awtomatikong makakakuha ng tamang anyo para sa bawat estilo.

Pag-load ng mga na-download na font

Kung ang font ay na-download mula sa network, i-save ito sa filesDir o cacheDir at i-load sa pamamagitan ng Typeface.createFromFile. Pagkatapos mag-load, i-update ang Typeface sa TextView. Para sa asynchronous na pag-load, gumamit ng coroutine o DownloadManager, at pagkatapos matapos, i-post sa UI thread sa pamamagitan ng Handler. Ito ay tipikal na scenario para sa mga application na may custom na tipograpiya na na-load on demand.

// I-save ang font file sa internal storage
val fontFile = File(context.cacheDir, "downloaded-font.otf")
fontFile.outputStream().use { output ->
    // input stream mula sa network
    inputStream.copyTo(output)
}
// Lumikha ng Typeface mula sa file
val downloadedTypeface = Typeface.createFromFile(fontFile)
textView.typeface = downloadedTypeface

Bago mag-load, suriin ang pagkakaroon ng file: kung ang file ay sira o hindi wasto, ang Typeface.createFromFile ay magtatapon ng RuntimeException. Inirerekomenda na balutin ang tawag sa try-catch at sa kaso ng error, panatilihin ang default system font.

Typeface sa Jetpack Compose

Sa Jetpack Compose, ang Typeface Android SDK ay hindi direktang ginagamit. Sa halip, ang Compose ay nagbibigay ng FontFamily at FontWeight para sa tipograpiya. Ang FontFamily ay nilo-load sa pamamagitan ng Font.Resource at Font.File. Ang sistema ng tipograpiya ng Compose ay itinatakda sa pamamagitan ng MaterialTheme.typography, kung saan ang bawat estilo (h1, body1, button) ay maaaring bigyan ng custom na FontFamily.

Para sa pag-load ng font mula sa resources, ang Compose ay gumagamit ng Font(R.font.font_name, weight, style). Ang font mula sa assets ay nilo-load sa pamamagitan ng Font(assetPath = "fonts/custom.otf", weight, style). Pagkatapos tukuyin ang font, ito ay ipinapasa sa Typography, pagkatapos ay inilalapat sa pamamagitan ng MaterialTheme.typography.bodyLarge at mga katulad na estilo.

Conversion ng Typeface sa Compose font

Kung mayroong handa na Typeface na ginawa sa pamamagitan ng Android SDK, maaari itong gamitin sa Compose sa pamamagitan ng TypefaceAdapter o sa pamamagitan ng paggawa ng FontFamily batay sa Typeface. Para dito, kunin ang Typeface mula sa Typeface.create at ipasa ito sa FontFamily.Custom(listOf(Font(typeface))). Gayunpaman, inirerekomenda na gamitin ang native approach na may Font.Resource dahil ito ay mas optimal para sa Compose.

Pagganap at caching

Ang pag-load ng font mula sa mga file ay isang potensyal na mahal na operasyon. Bawat tawag sa Typeface.createFromAsset o Typeface.createFromFile ay nagbabasa ng file mula sa disk, nagpa-parse nito, at gumagawa ng Typeface object. Para sa mga font na 1-2 MB, ito ay tumatagal ng 10-50 ms sa cold startup. Ang caching ng Typeface ay sapilitan para sa mga application na may custom na font.

Ang Android SDK ay hindi nagca-cache ng mga font na ginawa sa pamamagitan ng createFromAsset o createFromFile. Hindi tulad ng mga system font na pre-load sa proseso ng Zygote, ang mga custom na font ay nilo-load sa bawat pag-access. Inirerekomenda na gumamit ng LruCache o ConcurrentHashMap na may susi mula sa identifier ng font. Laki ng cache — 10-20 instance, na sumasaklaw sa tipikal na set ng font ng application.

Optimization sa pamamagitan ng Font Family (API 26+)

Ang Android 8.0+ ay nag-o-optimize ng pag-load ng font sa pamamagitan ng XML Font Family. Kapag tinutukoy ang android:fontFamily="@font/my_family" sa XML layout, ang Android ay naglo-load ng font nang tamad — tanging kapag ang component ay naging visible. Ang sistema ay nagca-cache din ng mga font na na-load sa pamamagitan ng ResourcesCompat.getFont() sa global cache ng proseso. Ito ang gumagawa ng paraang resource na pinaka-performant.

Typeface sa RecyclerView

Kapag gumagamit ng Typeface sa mga adapter ng RecyclerView mahalaga na huwag i-load ang font sa method na onBindViewHolder. Tawagin ang pag-load nang isang beses sa paggawa ng adapter o gumamit ng ViewHolder na may pre-loaded na Typeface. Kung ang bawat item ng listahan ay nangangailangan ng natatanging font, magpatupad ng cache sa pamamagitan ng WeakHashMap at linisin ito kapag nag-scroll lampas sa mga visible na posisyon upang makatipid ng memorya.