Home | History | Annotate | Download | only in ports 
      1 
      2 /*
      3  * Copyright 2013 The Android Open Source Project
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 
      9 #include "SkFontConfigInterface.h"
     10 #include "SkTypeface_android.h"
     11 
     12 #include "SkFontConfigParser_android.h"
     13 #include "SkFontConfigTypeface.h"
     14 #include "SkFontMgr.h"
     15 #include "SkGlyphCache.h"
     16 #include "SkPaint.h"
     17 #include "SkString.h"
     18 #include "SkStream.h"
     19 #include "SkThread.h"
     20 #include "SkTypefaceCache.h"
     21 #include "SkTArray.h"
     22 #include "SkTDict.h"
     23 #include "SkTSearch.h"
     24 
     25 #include <stdio.h>
     26 #include <string.h>
     27 
     28 #ifndef SK_DEBUG_FONTS
     29     #define SK_DEBUG_FONTS 0
     30 #endif
     31 
     32 #if SK_DEBUG_FONTS
     33     #define DEBUG_FONT(args) SkDebugf args
     34 #else
     35     #define DEBUG_FONT(args)
     36 #endif
     37 
     38 ///////////////////////////////////////////////////////////////////////////////
     39 
     40 // For test only.
     41 static const char* gTestMainConfigFile = NULL;
     42 static const char* gTestFallbackConfigFile = NULL;
     43 static const char* gTestFontFilePrefix = NULL;
     44 
     45 ///////////////////////////////////////////////////////////////////////////////
     46 
     47 typedef int32_t FontRecID;
     48 #define INVALID_FONT_REC_ID -1
     49 
     50 typedef int32_t FamilyRecID;
     51 #define INVALID_FAMILY_REC_ID -1
     52 
     53 // used to record our notion of the pre-existing fonts
     54 struct FontRec {
     55     SkRefPtr<SkTypeface> fTypeface;
     56     SkString fFileName;
     57     SkTypeface::Style fStyle;
     58     bool fIsValid;
     59     FamilyRecID fFamilyRecID;
     60 };
     61 
     62 struct FamilyRec {
     63     FamilyRec() {
     64         memset(fFontRecID, INVALID_FONT_REC_ID, sizeof(fFontRecID));
     65     }
     66 
     67     static const int FONT_STYLE_COUNT = 4;
     68     FontRecID fFontRecID[FONT_STYLE_COUNT];
     69     bool fIsFallbackFont;
     70     SkString fFallbackName;
     71     SkPaintOptionsAndroid fPaintOptions;
     72 };
     73 
     74 
     75 typedef SkTDArray<FamilyRecID> FallbackFontList;
     76 
     77 class SkFontConfigInterfaceAndroid : public SkFontConfigInterface {
     78 public:
     79     SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies);
     80     virtual ~SkFontConfigInterfaceAndroid();
     81 
     82     virtual bool matchFamilyName(const char familyName[],
     83                                  SkTypeface::Style requested,
     84                                  FontIdentity* outFontIdentifier,
     85                                  SkString* outFamilyName,
     86                                  SkTypeface::Style* outStyle) SK_OVERRIDE;
     87     virtual SkStream* openStream(const FontIdentity&) SK_OVERRIDE;
     88 
     89     // new APIs
     90     virtual SkDataTable* getFamilyNames() SK_OVERRIDE;
     91     virtual bool matchFamilySet(const char inFamilyName[],
     92                                 SkString* outFamilyName,
     93                                 SkTArray<FontIdentity>*) SK_OVERRIDE;
     94 
     95     /**
     96      *  Get the family name of the font in the default fallback font list that
     97      *  contains the specified chararacter. if no font is found, returns false.
     98      */
     99     bool getFallbackFamilyNameForChar(SkUnichar uni, const char* lang, SkString* name);
    100     /**
    101      *
    102      */
    103     SkTypeface* getTypefaceForChar(SkUnichar uni, SkTypeface::Style style,
    104                                    SkPaintOptionsAndroid::FontVariant fontVariant);
    105     SkTypeface* nextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
    106                                     const SkPaintOptionsAndroid& options);
    107     SkTypeface* getTypefaceForGlyphID(uint16_t glyphID, const SkTypeface* origTypeface,
    108                                       const SkPaintOptionsAndroid& options,
    109                                       int* lowerBounds, int* upperBounds);
    110 
    111 private:
    112     void addFallbackFamily(FamilyRecID fontRecID);
    113     SkTypeface* getTypefaceForFontRec(FontRecID fontRecID);
    114     FallbackFontList* getCurrentLocaleFallbackFontList();
    115     FallbackFontList* findFallbackFontList(const SkLanguage& lang, bool isOriginal = true);
    116 
    117     SkTArray<FontRec> fFonts;
    118     SkTArray<FamilyRec> fFontFamilies;
    119     SkTDict<FamilyRecID> fFamilyNameDict;
    120     FamilyRecID fDefaultFamilyRecID;
    121 
    122     // (SkLanguage)<->(fallback chain index) translation
    123     SkTDict<FallbackFontList*> fFallbackFontDict;
    124     SkTDict<FallbackFontList*> fFallbackFontAliasDict;
    125     FallbackFontList fDefaultFallbackList;
    126 
    127     // fallback info for current locale
    128     SkString fCachedLocale;
    129     FallbackFontList* fLocaleFallbackFontList;
    130 };
    131 
    132 ///////////////////////////////////////////////////////////////////////////////
    133 
    134 static SkFontConfigInterfaceAndroid* getSingletonInterface() {
    135     SK_DECLARE_STATIC_MUTEX(gMutex);
    136     static SkFontConfigInterfaceAndroid* gFontConfigInterface;
    137 
    138     SkAutoMutexAcquire ac(gMutex);
    139     if (NULL == gFontConfigInterface) {
    140         // load info from a configuration file that we can use to populate the
    141         // system/fallback font structures
    142         SkTDArray<FontFamily*> fontFamilies;
    143         if (!gTestMainConfigFile) {
    144             SkFontConfigParser::GetFontFamilies(fontFamilies);
    145         } else {
    146             SkFontConfigParser::GetTestFontFamilies(fontFamilies, gTestMainConfigFile,
    147                                                     gTestFallbackConfigFile);
    148         }
    149 
    150         gFontConfigInterface = new SkFontConfigInterfaceAndroid(fontFamilies);
    151 
    152         // cleanup the data we received from the parser
    153         fontFamilies.deleteAll();
    154     }
    155     return gFontConfigInterface;
    156 }
    157 
    158 SkFontConfigInterface* SkFontConfigInterface::GetSingletonDirectInterface() {
    159     return getSingletonInterface();
    160 }
    161 
    162 ///////////////////////////////////////////////////////////////////////////////
    163 
    164 static bool has_font(const SkTArray<FontRec>& array, const SkString& filename) {
    165     for (int i = 0; i < array.count(); i++) {
    166         if (array[i].fFileName == filename) {
    167             return true;
    168         }
    169     }
    170     return false;
    171 }
    172 
    173 #ifndef SK_FONT_FILE_PREFIX
    174     #define SK_FONT_FILE_PREFIX          "/fonts/"
    175 #endif
    176 
    177 static void get_path_for_sys_fonts(SkString* full, const SkString& name) {
    178     if (gTestFontFilePrefix) {
    179         full->set(gTestFontFilePrefix);
    180     } else {
    181         full->set(getenv("ANDROID_ROOT"));
    182         full->append(SK_FONT_FILE_PREFIX);
    183     }
    184     full->append(name);
    185 }
    186 
    187 static void insert_into_name_dict(SkTDict<FamilyRecID>& familyNameDict,
    188                                   const char* name, FamilyRecID familyRecID) {
    189     SkAutoAsciiToLC tolc(name);
    190     if (familyNameDict.find(tolc.lc())) {
    191         SkDebugf("---- system font attempting to use a the same name [%s] for"
    192                  "multiple families. skipping subsequent occurrences", tolc.lc());
    193     } else {
    194         familyNameDict.set(tolc.lc(), familyRecID);
    195     }
    196 }
    197 
    198 // Defined in SkFontHost_FreeType.cpp
    199 bool find_name_and_attributes(SkStream* stream, SkString* name,
    200                               SkTypeface::Style* style, bool* isFixedWidth);
    201 
    202 ///////////////////////////////////////////////////////////////////////////////
    203 
    204 SkFontConfigInterfaceAndroid::SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies) :
    205         fFonts(fontFamilies.count()),
    206         fFontFamilies(fontFamilies.count() / FamilyRec::FONT_STYLE_COUNT),
    207         fFamilyNameDict(1024),
    208         fDefaultFamilyRecID(INVALID_FAMILY_REC_ID),
    209         fFallbackFontDict(128),
    210         fFallbackFontAliasDict(128),
    211         fLocaleFallbackFontList(NULL) {
    212 
    213     for (int i = 0; i < fontFamilies.count(); ++i) {
    214         FontFamily* family = fontFamilies[i];
    215 
    216         // defer initializing the familyRec until we can be sure that at least
    217         // one of it's children contains a valid font file
    218         FamilyRec* familyRec = NULL;
    219         FamilyRecID familyRecID = INVALID_FAMILY_REC_ID;
    220 
    221         for (int j = 0; j < family->fFontFiles.count(); ++j) {
    222             SkString filename;
    223             get_path_for_sys_fonts(&filename, family->fFontFiles[j].fFileName);
    224 
    225             if (has_font(fFonts, filename)) {
    226                 SkDebugf("---- system font and fallback font files specify a duplicate "
    227                         "font %s, skipping the second occurrence", filename.c_str());
    228                 continue;
    229             }
    230 
    231             FontRec& fontRec = fFonts.push_back();
    232             fontRec.fFileName = filename;
    233             fontRec.fStyle = SkTypeface::kNormal;
    234             fontRec.fIsValid = false;
    235             fontRec.fFamilyRecID = familyRecID;
    236 
    237             const FontRecID fontRecID = fFonts.count() - 1;
    238 
    239             SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
    240             if (stream.get() != NULL) {
    241                 bool isFixedWidth;
    242                 SkString name;
    243                 fontRec.fIsValid = find_name_and_attributes(stream.get(), &name,
    244                                                             &fontRec.fStyle, &isFixedWidth);
    245             } else {
    246                 if (!family->fIsFallbackFont) {
    247                     SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
    248                 }
    249             }
    250 
    251             if (fontRec.fIsValid) {
    252                 DEBUG_FONT(("---- SystemFonts[%d][%d] fallback=%d file=%s",
    253                            i, fFonts.count() - 1, family->fIsFallbackFont, filename.c_str()));
    254             } else {
    255                 DEBUG_FONT(("---- SystemFonts[%d][%d] fallback=%d file=%s (INVALID)",
    256                            i, fFonts.count() - 1, family->fIsFallbackFont, filename.c_str()));
    257                 continue;
    258             }
    259 
    260             // create a familyRec now that we know that at least one font in
    261             // the family is valid
    262             if (familyRec == NULL) {
    263                 familyRec = &fFontFamilies.push_back();
    264                 familyRecID = fFontFamilies.count() - 1;
    265                 fontRec.fFamilyRecID = familyRecID;
    266 
    267                 familyRec->fIsFallbackFont = family->fIsFallbackFont;
    268                 familyRec->fPaintOptions = family->fFontFiles[j].fPaintOptions;
    269 
    270             } else if (familyRec->fPaintOptions != family->fFontFiles[j].fPaintOptions) {
    271                 SkDebugf("Every font file within a family must have identical"
    272                          "language and variant attributes");
    273                 sk_throw();
    274             }
    275 
    276             // add this font to the current familyRec
    277             if (INVALID_FONT_REC_ID != familyRec->fFontRecID[fontRec.fStyle]) {
    278                 DEBUG_FONT(("Overwriting familyRec for style[%d] old,new:(%d,%d)",
    279                             fontRec.fStyle, familyRec->fFontRecID[fontRec.fStyle],
    280                             fontRecID));
    281             }
    282             familyRec->fFontRecID[fontRec.fStyle] = fontRecID;
    283         }
    284 
    285         if (familyRec) {
    286             if (familyRec->fIsFallbackFont) {
    287                 // add the font to the appropriate fallback chains and also insert a
    288                 // unique name into the familyNameDict for internal usage
    289                 addFallbackFamily(familyRecID);
    290             } else {
    291                 // add the names that map to this family to the dictionary for easy lookup
    292                 const SkTArray<SkString>& names = family->fNames;
    293                 if (names.empty()) {
    294                     SkDEBUGFAIL("ERROR: non-fallback font with no name");
    295                     continue;
    296                 }
    297 
    298                 for (int i = 0; i < names.count(); i++) {
    299                     insert_into_name_dict(fFamilyNameDict, names[i].c_str(), familyRecID);
    300                 }
    301             }
    302         }
    303     }
    304 
    305     DEBUG_FONT(("---- We have %d system fonts", fFonts.count()));
    306 
    307     if (fFontFamilies.count() > 0) {
    308         fDefaultFamilyRecID = 0;
    309     }
    310 
    311     // scans the default fallback font chain, adding every entry to every other
    312     // fallback font chain to which it does not belong. this results in every
    313     // language-specific fallback font chain having all of its fallback fonts at
    314     // the front of the chain, and everything else at the end.
    315     FallbackFontList* fallbackList;
    316     SkTDict<FallbackFontList*>::Iter iter(fFallbackFontDict);
    317     const char* fallbackLang = iter.next(&fallbackList);
    318     while(fallbackLang != NULL) {
    319         for (int i = 0; i < fDefaultFallbackList.count(); i++) {
    320             FamilyRecID familyRecID = fDefaultFallbackList[i];
    321             const SkString& fontLang = fFontFamilies[familyRecID].fPaintOptions.getLanguage().getTag();
    322             if (strcmp(fallbackLang, fontLang.c_str()) != 0) {
    323                 fallbackList->push(familyRecID);
    324             }
    325         }
    326         // move to the next fallback list in the dictionary
    327         fallbackLang = iter.next(&fallbackList);
    328     }
    329 }
    330 
    331 SkFontConfigInterfaceAndroid::~SkFontConfigInterfaceAndroid() {
    332     // iterate through and cleanup fFallbackFontDict
    333     SkTDict<FallbackFontList*>::Iter iter(fFallbackFontDict);
    334     FallbackFontList* fallbackList;
    335     while(iter.next(&fallbackList) != NULL) {
    336         SkDELETE(fallbackList);
    337     }
    338 }
    339 
    340 void SkFontConfigInterfaceAndroid::addFallbackFamily(FamilyRecID familyRecID) {
    341     SkASSERT(familyRecID < fFontFamilies.count());
    342     FamilyRec& familyRec = fFontFamilies[familyRecID];
    343     SkASSERT(familyRec.fIsFallbackFont);
    344 
    345     // add the fallback family to the name dictionary.  This is
    346     // needed by getFallbackFamilyNameForChar() so that fallback
    347     // families can be identified by a unique name. The unique
    348     // identifier that we've chosen is the familyID in hex (e.g. '0F##fallback').
    349     familyRec.fFallbackName.printf("%.2x##fallback", familyRecID);
    350     insert_into_name_dict(fFamilyNameDict, familyRec.fFallbackName.c_str(), familyRecID);
    351 
    352     // add to the default fallback list
    353     fDefaultFallbackList.push(familyRecID);
    354 
    355     // stop here if it is the default language tag
    356     const SkString& languageTag = familyRec.fPaintOptions.getLanguage().getTag();
    357     if (languageTag.isEmpty()) {
    358         return;
    359     }
    360 
    361     // add to the appropriate language's custom fallback list
    362     FallbackFontList* customList = NULL;
    363     if (!fFallbackFontDict.find(languageTag.c_str(), &customList)) {
    364         DEBUG_FONT(("----  Created fallback list for \"%s\"", languageTag.c_str()));
    365         customList = SkNEW(FallbackFontList);
    366         fFallbackFontDict.set(languageTag.c_str(), customList);
    367     }
    368     SkASSERT(customList != NULL);
    369     customList->push(familyRecID);
    370 }
    371 
    372 
    373 static FontRecID find_best_style(const FamilyRec& family, SkTypeface::Style style) {
    374 
    375     const FontRecID* fontRecIDs = family.fFontRecID;
    376 
    377     if (fontRecIDs[style] != INVALID_FONT_REC_ID) { // exact match
    378         return fontRecIDs[style];
    379     }
    380     // look for a matching bold
    381     style = (SkTypeface::Style)(style ^ SkTypeface::kItalic);
    382     if (fontRecIDs[style] != INVALID_FONT_REC_ID) {
    383         return fontRecIDs[style];
    384     }
    385     // look for the plain
    386     if (fontRecIDs[SkTypeface::kNormal] != INVALID_FONT_REC_ID) {
    387         return fontRecIDs[SkTypeface::kNormal];
    388     }
    389     // look for anything
    390     for (int i = 0; i < FamilyRec::FONT_STYLE_COUNT; i++) {
    391         if (fontRecIDs[i] != INVALID_FONT_REC_ID) {
    392             return fontRecIDs[i];
    393         }
    394     }
    395     // should never get here, since the fontRecID list should not be empty
    396     SkDEBUGFAIL("No valid fonts exist for this family");
    397     return -1;
    398 }
    399 
    400 bool SkFontConfigInterfaceAndroid::matchFamilyName(const char familyName[],
    401                                                    SkTypeface::Style style,
    402                                                    FontIdentity* outFontIdentifier,
    403                                                    SkString* outFamilyName,
    404                                                    SkTypeface::Style* outStyle) {
    405     // clip to legal style bits
    406     style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
    407 
    408     bool exactNameMatch = false;
    409 
    410     FamilyRecID familyRecID = INVALID_FAMILY_REC_ID;
    411     if (NULL != familyName) {
    412         SkAutoAsciiToLC tolc(familyName);
    413         if (fFamilyNameDict.find(tolc.lc(), &familyRecID)) {
    414             exactNameMatch = true;
    415         }
    416     } else {
    417         familyRecID = fDefaultFamilyRecID;
    418 
    419     }
    420 
    421     // If no matching family name is found then return false. This allows clients
    422     // to be able to search for other fonts instead of forcing them to use the
    423     // default font.
    424     if (INVALID_FAMILY_REC_ID == familyRecID) {
    425         return false;
    426     }
    427 
    428     FontRecID fontRecID = find_best_style(fFontFamilies[familyRecID], style);
    429     FontRec& fontRec = fFonts[fontRecID];
    430 
    431     if (NULL != outFontIdentifier) {
    432         outFontIdentifier->fID = fontRecID;
    433         outFontIdentifier->fTTCIndex = 0;
    434         outFontIdentifier->fString.set(fontRec.fFileName);
    435 //        outFontIdentifier->fStyle = fontRec.fStyle;
    436     }
    437 
    438     if (NULL != outFamilyName) {
    439         if (exactNameMatch) {
    440             outFamilyName->set(familyName);
    441         } else {
    442             // find familyName from list of names
    443             const char* familyName = NULL;
    444             SkAssertResult(fFamilyNameDict.findKey(familyRecID, &familyName));
    445             SkASSERT(familyName);
    446             outFamilyName->set(familyName);
    447         }
    448     }
    449 
    450     if (NULL != outStyle) {
    451         *outStyle = fontRec.fStyle;
    452     }
    453 
    454     return true;
    455 }
    456 
    457 SkStream* SkFontConfigInterfaceAndroid::openStream(const FontIdentity& identity) {
    458     return SkStream::NewFromFile(identity.fString.c_str());
    459 }
    460 
    461 SkDataTable* SkFontConfigInterfaceAndroid::getFamilyNames() {
    462     SkTDArray<const char*> names;
    463     SkTDArray<size_t> sizes;
    464 
    465     SkTDict<FamilyRecID>::Iter iter(fFamilyNameDict);
    466     const char* familyName = iter.next(NULL);
    467     while(familyName != NULL) {
    468         *names.append() = familyName;
    469         *sizes.append() = strlen(familyName) + 1;
    470 
    471         // move to the next familyName in the dictionary
    472         familyName = iter.next(NULL);
    473     }
    474 
    475     return SkDataTable::NewCopyArrays((const void*const*)names.begin(),
    476                                       sizes.begin(), names.count());
    477 }
    478 
    479 bool SkFontConfigInterfaceAndroid::matchFamilySet(const char inFamilyName[],
    480                                                   SkString* outFamilyName,
    481                                                   SkTArray<FontIdentity>*) {
    482     return false;
    483 }
    484 
    485 static bool find_proc(SkTypeface* face, SkTypeface::Style style, void* ctx) {
    486     const FontRecID* fontRecID = (const FontRecID*)ctx;
    487     FontRecID currFontRecID = ((FontConfigTypeface*)face)->getIdentity().fID;
    488     return currFontRecID == *fontRecID;
    489 }
    490 
    491 SkTypeface* SkFontConfigInterfaceAndroid::getTypefaceForFontRec(FontRecID fontRecID) {
    492     FontRec& fontRec = fFonts[fontRecID];
    493     SkTypeface* face = fontRec.fTypeface.get();
    494     if (!face) {
    495         // look for it in the typeface cache
    496         face = SkTypefaceCache::FindByProcAndRef(find_proc, &fontRecID);
    497 
    498         // if it is not in the cache then create it
    499         if (!face) {
    500             const char* familyName = NULL;
    501             SkAssertResult(fFamilyNameDict.findKey(fontRec.fFamilyRecID, &familyName));
    502             SkASSERT(familyName);
    503             face = SkTypeface::CreateFromName(familyName, fontRec.fStyle);
    504         }
    505 
    506         // store the result for subsequent lookups
    507         fontRec.fTypeface = face;
    508     }
    509     SkASSERT(face);
    510     return face;
    511 }
    512 
    513 bool SkFontConfigInterfaceAndroid::getFallbackFamilyNameForChar(SkUnichar uni,
    514                                                                 const char* lang,
    515                                                                 SkString* name) {
    516     FallbackFontList* fallbackFontList = NULL;
    517     const SkString langTag(lang);
    518     if (langTag.isEmpty()) {
    519         fallbackFontList = this->getCurrentLocaleFallbackFontList();
    520     } else {
    521         fallbackFontList = this->findFallbackFontList(langTag);
    522     }
    523 
    524     for (int i = 0; i < fallbackFontList->count(); i++) {
    525         FamilyRecID familyRecID = fallbackFontList->getAt(i);
    526 
    527         // if it is not one of the accepted variants then move to the next family
    528         int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant |
    529                                    SkPaintOptionsAndroid::kElegant_Variant;
    530         if (!(fFontFamilies[familyRecID].fPaintOptions.getFontVariant() & acceptedVariants)) {
    531             continue;
    532         }
    533 
    534         FontRecID fontRecID = find_best_style(fFontFamilies[familyRecID], SkTypeface::kNormal);
    535         SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
    536 
    537         SkPaint paint;
    538         paint.setTypeface(face);
    539         paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
    540 
    541         uint16_t glyphID;
    542         paint.textToGlyphs(&uni, sizeof(uni), &glyphID);
    543         if (glyphID != 0) {
    544             name->set(fFontFamilies[familyRecID].fFallbackName);
    545             return true;
    546         }
    547     }
    548     return false;
    549 }
    550 
    551 SkTypeface* SkFontConfigInterfaceAndroid::getTypefaceForChar(SkUnichar uni,
    552                                                              SkTypeface::Style style,
    553                                                              SkPaintOptionsAndroid::FontVariant fontVariant) {
    554     FontRecID fontRecID = find_best_style(fFontFamilies[fDefaultFamilyRecID], style);
    555     SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
    556 
    557     SkPaintOptionsAndroid paintOptions;
    558     paintOptions.setFontVariant(fontVariant);
    559     paintOptions.setUseFontFallbacks(true);
    560 
    561     SkPaint paint;
    562     paint.setTypeface(face);
    563     paint.setTextEncoding(SkPaint::kUTF16_TextEncoding);
    564     paint.setPaintOptionsAndroid(paintOptions);
    565 
    566     SkAutoGlyphCache autoCache(paint, NULL, NULL);
    567     SkGlyphCache*    cache = autoCache.getCache();
    568 
    569     SkScalerContext* ctx = cache->getScalerContext();
    570     if (ctx) {
    571         SkFontID fontID = ctx->findTypefaceIdForChar(uni);
    572         return SkTypefaceCache::FindByID(fontID);
    573     }
    574     return NULL;
    575 }
    576 
    577 FallbackFontList* SkFontConfigInterfaceAndroid::getCurrentLocaleFallbackFontList() {
    578     SkString locale = SkFontConfigParser::GetLocale();
    579     if (NULL == fLocaleFallbackFontList || locale != fCachedLocale) {
    580         fCachedLocale = locale;
    581         fLocaleFallbackFontList = this->findFallbackFontList(locale);
    582     }
    583     return fLocaleFallbackFontList;
    584 }
    585 
    586 FallbackFontList* SkFontConfigInterfaceAndroid::findFallbackFontList(const SkLanguage& lang,
    587                                                                      bool isOriginal) {
    588     const SkString& langTag = lang.getTag();
    589     if (langTag.isEmpty()) {
    590         return &fDefaultFallbackList;
    591     }
    592 
    593     FallbackFontList* fallbackFontList;
    594     if (fFallbackFontDict.find(langTag.c_str(), langTag.size(), &fallbackFontList) ||
    595         fFallbackFontAliasDict.find(langTag.c_str(), langTag.size(), &fallbackFontList)) {
    596         return fallbackFontList;
    597     }
    598 
    599     // attempt a recursive fuzzy match
    600     SkLanguage parent = lang.getParent();
    601     fallbackFontList = findFallbackFontList(parent, false);
    602 
    603     // cache the original lang so we don't have to do the recursion again.
    604     if (isOriginal) {
    605         DEBUG_FONT(("----  Created fallback list alias for \"%s\"", langTag.c_str()));
    606         fFallbackFontAliasDict.set(langTag.c_str(), fallbackFontList);
    607     }
    608     return fallbackFontList;
    609 }
    610 
    611 SkTypeface* SkFontConfigInterfaceAndroid::nextLogicalTypeface(SkFontID currFontID,
    612                                                               SkFontID origFontID,
    613                                                               const SkPaintOptionsAndroid& opts) {
    614     // Skia does not support font fallback by default. This enables clients such
    615     // as WebKit to customize their font selection. In any case, clients can use
    616     // GetFallbackFamilyNameForChar() to get the fallback font for individual
    617     // characters.
    618     if (!opts.isUsingFontFallbacks()) {
    619         return NULL;
    620     }
    621 
    622     FallbackFontList* currentFallbackList = findFallbackFontList(opts.getLanguage());
    623     SkASSERT(currentFallbackList);
    624 
    625     SkTypeface::Style origStyle = SkTypeface::kNormal;
    626     const SkTypeface* origTypeface = SkTypefaceCache::FindByID(origFontID);
    627     if (NULL != origTypeface) {
    628         origStyle = origTypeface->style();
    629     }
    630 
    631     // we must convert currTypeface into a FontRecID
    632     FontRecID currFontRecID = INVALID_FONT_REC_ID;
    633     const SkTypeface* currTypeface = SkTypefaceCache::FindByID(currFontID);
    634     // non-system fonts are not in the font cache so if we are asked to fallback
    635     // for a non-system font we will start at the front of the chain.
    636     if (NULL != currTypeface) {
    637         currFontRecID = ((FontConfigTypeface*)currTypeface)->getIdentity().fID;
    638         SkASSERT(INVALID_FONT_REC_ID != currFontRecID);
    639     }
    640 
    641     FamilyRecID currFamilyRecID = INVALID_FAMILY_REC_ID;
    642     if (INVALID_FONT_REC_ID != currFontRecID) {
    643         currFamilyRecID = fFonts[currFontRecID].fFamilyRecID;
    644     }
    645 
    646     // lookup the index next font in the chain
    647     int currFallbackFontIndex = currentFallbackList->find(currFamilyRecID);
    648     // We add 1 to the returned index for 2 reasons: (1) if find succeeds it moves
    649     // our index to the next entry in the list; (2) if find() fails it returns
    650     // -1 and incrementing it will set our starting index to 0 (the head of the list)
    651     int nextFallbackFontIndex = currFallbackFontIndex + 1;
    652 
    653     if(nextFallbackFontIndex >= currentFallbackList->count()) {
    654         return NULL;
    655     }
    656 
    657     // If a rec object is set to prefer "kDefault_Variant" it means they have no preference
    658     // In this case, we set the value to "kCompact_Variant"
    659     SkPaintOptionsAndroid::FontVariant variant = opts.getFontVariant();
    660     if (variant == SkPaintOptionsAndroid::kDefault_Variant) {
    661         variant = SkPaintOptionsAndroid::kCompact_Variant;
    662     }
    663 
    664     int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant | variant;
    665 
    666     SkTypeface* nextLogicalTypeface = 0;
    667     while (nextFallbackFontIndex < currentFallbackList->count()) {
    668         FamilyRecID familyRecID = currentFallbackList->getAt(nextFallbackFontIndex);
    669         if ((fFontFamilies[familyRecID].fPaintOptions.getFontVariant() & acceptedVariants) != 0) {
    670             FontRecID matchedFont = find_best_style(fFontFamilies[familyRecID], origStyle);
    671             nextLogicalTypeface = this->getTypefaceForFontRec(matchedFont);
    672             break;
    673         }
    674         nextFallbackFontIndex++;
    675     }
    676 
    677     DEBUG_FONT(("---- nextLogicalFont: currFontID=%d, origFontID=%d, currRecID=%d, "
    678                 "lang=%s, variant=%d, nextFallbackIndex[%d,%d] => nextLogicalTypeface=%d",
    679                 currFontID, origFontID, currFontRecID, opts.getLanguage().getTag().c_str(),
    680                 variant, nextFallbackFontIndex, currentFallbackList->getAt(nextFallbackFontIndex),
    681                 (nextLogicalTypeface) ? nextLogicalTypeface->uniqueID() : 0));
    682     return SkSafeRef(nextLogicalTypeface);
    683 }
    684 
    685 SkTypeface* SkFontConfigInterfaceAndroid::getTypefaceForGlyphID(uint16_t glyphID,
    686                                                                 const SkTypeface* origTypeface,
    687                                                                 const SkPaintOptionsAndroid& opts,
    688                                                                 int* lBounds, int* uBounds) {
    689     // If we aren't using fallbacks then we shouldn't be calling this
    690     SkASSERT(opts.isUsingFontFallbacks());
    691     SkASSERT(origTypeface);
    692 
    693     SkTypeface* currentTypeface = NULL;
    694     int lowerBounds = 0; //inclusive
    695     int upperBounds = origTypeface->countGlyphs(); //exclusive
    696 
    697     // check to see if the glyph is in the bounds of the origTypeface
    698     if (glyphID < upperBounds) {
    699         currentTypeface = const_cast<SkTypeface*>(origTypeface);
    700     } else {
    701         FallbackFontList* currentFallbackList = findFallbackFontList(opts.getLanguage());
    702         SkASSERT(currentFallbackList);
    703 
    704         // If an object is set to prefer "kDefault_Variant" it means they have no preference
    705         // In this case, we set the value to "kCompact_Variant"
    706         SkPaintOptionsAndroid::FontVariant variant = opts.getFontVariant();
    707         if (variant == SkPaintOptionsAndroid::kDefault_Variant) {
    708             variant = SkPaintOptionsAndroid::kCompact_Variant;
    709         }
    710 
    711         int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant | variant;
    712         SkTypeface::Style origStyle = origTypeface->style();
    713 
    714         for (int x = 0; x < currentFallbackList->count(); ++x) {
    715             const FamilyRecID familyRecID = currentFallbackList->getAt(x);
    716             const SkPaintOptionsAndroid& familyOptions = fFontFamilies[familyRecID].fPaintOptions;
    717             if ((familyOptions.getFontVariant() & acceptedVariants) != 0) {
    718                 FontRecID matchedFont = find_best_style(fFontFamilies[familyRecID], origStyle);
    719                 currentTypeface = this->getTypefaceForFontRec(matchedFont);
    720                 lowerBounds = upperBounds;
    721                 upperBounds += currentTypeface->countGlyphs();
    722                 if (glyphID < upperBounds) {
    723                     break;
    724                 }
    725             }
    726         }
    727     }
    728 
    729     if (NULL != currentTypeface) {
    730         if (lBounds) {
    731             *lBounds = lowerBounds;
    732         }
    733         if (uBounds) {
    734             *uBounds = upperBounds;
    735         }
    736     }
    737     return currentTypeface;
    738 }
    739 
    740 ///////////////////////////////////////////////////////////////////////////////
    741 
    742 bool SkGetFallbackFamilyNameForChar(SkUnichar uni, SkString* name) {
    743     SkFontConfigInterfaceAndroid* fontConfig = getSingletonInterface();
    744     return fontConfig->getFallbackFamilyNameForChar(uni, NULL, name);
    745 }
    746 
    747 bool SkGetFallbackFamilyNameForChar(SkUnichar uni, const char* lang, SkString* name) {
    748     SkFontConfigInterfaceAndroid* fontConfig = getSingletonInterface();
    749     return fontConfig->getFallbackFamilyNameForChar(uni, lang, name);
    750 }
    751 
    752 void SkUseTestFontConfigFile(const char* mainconf, const char* fallbackconf,
    753                              const char* fontsdir) {
    754     gTestMainConfigFile = mainconf;
    755     gTestFallbackConfigFile = fallbackconf;
    756     gTestFontFilePrefix = fontsdir;
    757     SkASSERT(gTestMainConfigFile);
    758     SkASSERT(gTestFallbackConfigFile);
    759     SkASSERT(gTestFontFilePrefix);
    760     SkDEBUGF(("Use Test Config File Main %s, Fallback %s, Font Dir %s",
    761               gTestMainConfigFile, gTestFallbackConfigFile, gTestFontFilePrefix));
    762 }
    763 
    764 SkTypeface* SkAndroidNextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
    765                                          const SkPaintOptionsAndroid& options) {
    766     SkFontConfigInterfaceAndroid* fontConfig = getSingletonInterface();
    767     return fontConfig->nextLogicalTypeface(currFontID, origFontID, options);
    768 
    769 }
    770 
    771 SkTypeface* SkGetTypefaceForGlyphID(uint16_t glyphID, const SkTypeface* origTypeface,
    772                                     const SkPaintOptionsAndroid& options,
    773                                     int* lowerBounds, int* upperBounds) {
    774     SkFontConfigInterfaceAndroid* fontConfig = getSingletonInterface();
    775     return fontConfig->getTypefaceForGlyphID(glyphID, origTypeface, options,
    776                                              lowerBounds, upperBounds);
    777 }
    778 
    779 ///////////////////////////////////////////////////////////////////////////////
    780 
    781 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    782 
    783 struct HB_UnicodeMapping {
    784     hb_script_t script;
    785     const SkUnichar unicode;
    786 };
    787 
    788 /*
    789  * The following scripts are not complex fonts and we do not expect them to be parsed by this table
    790  * HB_SCRIPT_COMMON,
    791  * HB_SCRIPT_GREEK,
    792  * HB_SCRIPT_CYRILLIC,
    793  * HB_SCRIPT_HANGUL
    794  * HB_SCRIPT_INHERITED
    795  */
    796 
    797 /* Harfbuzz (old) is missing a number of scripts in its table. For these,
    798  * we include a value which can never happen. We won't get complex script
    799  * shaping in these cases, but the library wouldn't know how to shape
    800  * them anyway. */
    801 #define HB_Script_Unknown HB_ScriptCount
    802 
    803 static HB_UnicodeMapping HB_UnicodeMappingArray[] = {
    804     {HB_SCRIPT_ARMENIAN,    0x0531},
    805     {HB_SCRIPT_HEBREW,      0x0591},
    806     {HB_SCRIPT_ARABIC,      0x0600},
    807     {HB_SCRIPT_SYRIAC,      0x0710},
    808     {HB_SCRIPT_THAANA,      0x0780},
    809     {HB_SCRIPT_NKO,         0x07C0},
    810     {HB_SCRIPT_DEVANAGARI,  0x0901},
    811     {HB_SCRIPT_BENGALI,     0x0981},
    812     {HB_SCRIPT_GURMUKHI,    0x0A10},
    813     {HB_SCRIPT_GUJARATI,    0x0A90},
    814     {HB_SCRIPT_ORIYA,       0x0B10},
    815     {HB_SCRIPT_TAMIL,       0x0B82},
    816     {HB_SCRIPT_TELUGU,      0x0C10},
    817     {HB_SCRIPT_KANNADA,     0x0C90},
    818     {HB_SCRIPT_MALAYALAM,   0x0D10},
    819     {HB_SCRIPT_SINHALA,     0x0D90},
    820     {HB_SCRIPT_THAI,        0x0E01},
    821     {HB_SCRIPT_LAO,         0x0E81},
    822     {HB_SCRIPT_TIBETAN,     0x0F00},
    823     {HB_SCRIPT_MYANMAR,     0x1000},
    824     {HB_SCRIPT_GEORGIAN,    0x10A0},
    825     {HB_SCRIPT_ETHIOPIC,    0x1200},
    826     {HB_SCRIPT_CHEROKEE,    0x13A0},
    827     {HB_SCRIPT_OGHAM,       0x1680},
    828     {HB_SCRIPT_RUNIC,       0x16A0},
    829     {HB_SCRIPT_KHMER,       0x1780},
    830     {HB_SCRIPT_TAI_LE,      0x1950},
    831     {HB_SCRIPT_NEW_TAI_LUE, 0x1980},
    832     {HB_SCRIPT_TAI_THAM,    0x1A20},
    833     {HB_SCRIPT_CHAM,        0xAA00},
    834 };
    835 
    836 // returns 0 for "Not Found"
    837 static SkUnichar getUnicodeFromHBScript(hb_script_t script) {
    838     SkUnichar unichar = 0;
    839     int numSupportedFonts = sizeof(HB_UnicodeMappingArray) / sizeof(HB_UnicodeMapping);
    840     for (int i = 0; i < numSupportedFonts; i++) {
    841         if (script == HB_UnicodeMappingArray[i].script) {
    842             unichar = HB_UnicodeMappingArray[i].unicode;
    843             break;
    844         }
    845     }
    846     return unichar;
    847 }
    848 
    849 struct TypefaceLookupStruct {
    850     hb_script_t script;
    851     SkTypeface::Style style;
    852     SkPaintOptionsAndroid::FontVariant fontVariant;
    853     SkTypeface* typeface;
    854 };
    855 
    856 SK_DECLARE_STATIC_MUTEX(gTypefaceTableMutex);  // This is the mutex for gTypefaceTable
    857 static SkTDArray<TypefaceLookupStruct> gTypefaceTable;  // This is protected by gTypefaceTableMutex
    858 
    859 static int typefaceLookupCompare(const TypefaceLookupStruct& first,
    860                                  const TypefaceLookupStruct& second) {
    861     if (first.script != second.script) {
    862         return (first.script > second.script) ? 1 : -1;
    863     }
    864     if (first.style != second.style) {
    865         return (first.style > second.style) ? 1 : -1;
    866     }
    867     if (first.fontVariant != second.fontVariant) {
    868         return (first.fontVariant > second.fontVariant) ? 1 : -1;
    869     }
    870     return 0;
    871 }
    872 
    873 SkTypeface* SkCreateTypefaceForScript(hb_script_t script, SkTypeface::Style style,
    874                                       SkPaintOptionsAndroid::FontVariant fontVariant) {
    875     SkAutoMutexAcquire ac(gTypefaceTableMutex);
    876 
    877     TypefaceLookupStruct key;
    878     key.script = script;
    879     key.style = style;
    880     key.fontVariant = fontVariant;
    881 
    882     int index = SkTSearch<TypefaceLookupStruct>(
    883             (const TypefaceLookupStruct*) gTypefaceTable.begin(),
    884             gTypefaceTable.count(), key, sizeof(TypefaceLookupStruct),
    885             typefaceLookupCompare);
    886 
    887     SkTypeface* retTypeface = NULL;
    888     if (index >= 0) {
    889         retTypeface = gTypefaceTable[index].typeface;
    890     }
    891     else {
    892         SkUnichar unichar = getUnicodeFromHBScript(script);
    893         if (!unichar) {
    894             return NULL;
    895         }
    896 
    897         SkFontConfigInterfaceAndroid* fontConfig = getSingletonInterface();
    898         retTypeface = fontConfig->getTypefaceForChar(unichar, style, fontVariant);
    899 
    900         // add to the lookup table
    901         key.typeface = retTypeface;
    902         *gTypefaceTable.insert(~index) = key;
    903     }
    904 
    905     // we ref(), the caller is expected to unref when they are done
    906     return SkSafeRef(retTypeface);
    907 }
    908 
    909 #endif
    910 
    911 ///////////////////////////////////////////////////////////////////////////////
    912 
    913 SkFontMgr* SkFontMgr::Factory() {
    914     return NULL;
    915 }
    916