src/ports/SkFontMgr_android.cpp - skia - Git at Google

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "include/core/SkTypes.h"

 #include "include/core/SkData.h"
 #include "include/core/SkFontMgr.h"
 #include "include/core/SkFontStyle.h"
 #include "include/core/SkPaint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkStream.h"
 #include "include/core/SkString.h"
 #include "include/ports/SkFontMgr_android.h"
 #include "include/private/SkFixed.h"
 #include "include/private/SkTArray.h"
 #include "include/private/SkTDArray.h"
 #include "include/private/SkTemplates.h"
 #include "src/core/SkFontDescriptor.h"
 #include "src/core/SkOSFile.h"
 #include "src/core/SkTSearch.h"
 #include "src/core/SkTypefaceCache.h"
 #include "src/ports/SkFontHost_FreeType_common.h"
 #include "src/ports/SkFontMgr_android_parser.h"

 #include <algorithm>
 #include <limits>

 class SkData;

 class SkTypeface_Android : public SkTypeface_FreeType {
 public:
     SkTypeface_Android(const SkFontStyle& style,
                        bool isFixedPitch,
                        const SkString& familyName)
         : INHERITED(style, isFixedPitch)
         , fFamilyName(familyName)
         { }

 protected:
     void onGetFamilyName(SkString* familyName) const override {
         *familyName = fFamilyName;
     }

     SkString fFamilyName;

 private:
     using INHERITED = SkTypeface_FreeType;
 };

 class SkTypeface_AndroidSystem : public SkTypeface_Android {
 public:
     SkTypeface_AndroidSystem(const SkString& pathName,
                              const bool cacheFontFiles,
                              int index,
                              const SkFixed* axes, int axesCount,
                              const SkFontStyle& style,
                              bool isFixedPitch,
                              const SkString& familyName,
                              const SkTArray<SkLanguage, true>& lang,
                              FontVariant variantStyle)
         : INHERITED(style, isFixedPitch, familyName)
         , fPathName(pathName)
         , fIndex(index)
         , fAxes(axes, axesCount)
         , fLang(lang)
         , fVariantStyle(variantStyle)
         , fFile(cacheFontFiles ? sk_fopen(fPathName.c_str(), kRead_SkFILE_Flag) : nullptr) {
         if (cacheFontFiles) {
             SkASSERT(fFile);
         }
     }

     std::unique_ptr<SkStreamAsset> makeStream() const {
         if (fFile) {
             sk_sp<SkData> data(SkData::MakeFromFILE(fFile));
             return data ? std::make_unique<SkMemoryStream>(std::move(data)) : nullptr;
         }
         return SkStream::MakeFromFile(fPathName.c_str());
     }

     void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
         SkASSERT(desc);
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
         desc->setStyle(this->fontStyle());
         *serialize = false;
     }
     std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fIndex;
         return this->makeStream();
     }
     std::unique_ptr<SkFontData> onMakeFontData() const override {
         return std::make_unique<SkFontData>(this->makeStream(), fIndex,
                                               fAxes.begin(), fAxes.count());
     }
     sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
         std::unique_ptr<SkFontData> data = this->cloneFontData(args);
         if (!data) {
             return nullptr;
         }
         return sk_make_sp<SkTypeface_AndroidSystem>(fPathName,
                                                     fFile,
                                                     fIndex,
                                                     data->getAxis(),
                                                     data->getAxisCount(),
                                                     this->fontStyle(),
                                                     this->isFixedPitch(),
                                                     fFamilyName,
                                                     fLang,
                                                     fVariantStyle);
     }

     const SkString fPathName;
     int fIndex;
     const SkSTArray<4, SkFixed, true> fAxes;
     const SkSTArray<4, SkLanguage, true> fLang;
     const FontVariant fVariantStyle;
     SkAutoTCallVProc<FILE, sk_fclose> fFile;

     using INHERITED = SkTypeface_Android;
 };

 class SkTypeface_AndroidStream : public SkTypeface_Android {
 public:
     SkTypeface_AndroidStream(std::unique_ptr<SkFontData> data,
                              const SkFontStyle& style,
                              bool isFixedPitch,
                              const SkString& familyName)
         : INHERITED(style, isFixedPitch, familyName)
         , fData(std::move(data))
     { }

     void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
         SkASSERT(desc);
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
         *serialize = true;
     }

     std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fData->getIndex();
         return fData->getStream()->duplicate();
     }

     std::unique_ptr<SkFontData> onMakeFontData() const override {
         return std::make_unique<SkFontData>(*fData);
     }

     sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
         std::unique_ptr<SkFontData> data = this->cloneFontData(args);
         if (!data) {
             return nullptr;
         }
         return sk_make_sp<SkTypeface_AndroidStream>(std::move(data),
                                                     this->fontStyle(),
                                                     this->isFixedPitch(),
                                                     fFamilyName);
     }

 private:
     const std::unique_ptr<const SkFontData> fData;
     using INHERITED = SkTypeface_Android;
 };

 class SkFontStyleSet_Android : public SkFontStyleSet {
     typedef SkTypeface_FreeType::Scanner Scanner;

 public:
     explicit SkFontStyleSet_Android(const FontFamily& family, const Scanner& scanner,
                                     const bool cacheFontFiles) {
         const SkString* cannonicalFamilyName = nullptr;
         if (family.fNames.count() > 0) {
             cannonicalFamilyName = &family.fNames[0];
         }
         fFallbackFor = family.fFallbackFor;

         // TODO? make this lazy
         for (int i = 0; i < family.fFonts.count(); ++i) {
             const FontFileInfo& fontFile = family.fFonts[i];

             SkString pathName(family.fBasePath);
             pathName.append(fontFile.fFileName);

             std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(pathName.c_str());
             if (!stream) {
                 SkDEBUGF("Requested font file %s does not exist or cannot be opened.\n",
                          pathName.c_str());
                 continue;
             }

             const int ttcIndex = fontFile.fIndex;
             SkString familyName;
             SkFontStyle style;
             bool isFixedWidth;
             Scanner::AxisDefinitions axisDefinitions;
             if (!scanner.scanFont(stream.get(), ttcIndex,
                                   &familyName, &style, &isFixedWidth, &axisDefinitions))
             {
                 SkDEBUGF("Requested font file %s exists, but is not a valid font.\n",
                          pathName.c_str());
                 continue;
             }

             int weight = fontFile.fWeight != 0 ? fontFile.fWeight : style.weight();
             SkFontStyle::Slant slant = style.slant();
             switch (fontFile.fStyle) {
                 case FontFileInfo::Style::kAuto: slant = style.slant(); break;
                 case FontFileInfo::Style::kNormal: slant = SkFontStyle::kUpright_Slant; break;
                 case FontFileInfo::Style::kItalic: slant = SkFontStyle::kItalic_Slant; break;
                 default: SkASSERT(false); break;
             }
             style = SkFontStyle(weight, style.width(), slant);

             uint32_t variant = family.fVariant;
             if (kDefault_FontVariant == variant) {
                 variant = kCompact_FontVariant | kElegant_FontVariant;
             }

             // The first specified family name overrides the family name found in the font.
             // TODO: SkTypeface_AndroidSystem::onCreateFamilyNameIterator should return
             // all of the specified family names in addition to the names found in the font.
             if (cannonicalFamilyName != nullptr) {
                 familyName = *cannonicalFamilyName;
             }

             SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
             SkFontArguments::VariationPosition position = {
                 fontFile.fVariationDesignPosition.begin(),
                 fontFile.fVariationDesignPosition.count()
             };
             Scanner::computeAxisValues(axisDefinitions, position,
                                        axisValues, familyName);

             fStyles.push_back().reset(new SkTypeface_AndroidSystem(
                     pathName, cacheFontFiles, ttcIndex, axisValues.get(), axisDefinitions.count(),
                     style, isFixedWidth, familyName, family.fLanguages, variant));
         }
     }

     int count() override {
         return fStyles.count();
     }
     void getStyle(int index, SkFontStyle* style, SkString* name) override {
         if (index < 0 || fStyles.count() <= index) {
             return;
         }
         if (style) {
             *style = fStyles[index]->fontStyle();
         }
         if (name) {
             name->reset();
         }
     }
     SkTypeface_AndroidSystem* createTypeface(int index) override {
         if (index < 0 || fStyles.count() <= index) {
             return nullptr;
         }
         return SkRef(fStyles[index].get());
     }

     SkTypeface_AndroidSystem* matchStyle(const SkFontStyle& pattern) override {
         return static_cast<SkTypeface_AndroidSystem*>(this->matchStyleCSS3(pattern));
     }

 private:
     SkTArray<sk_sp<SkTypeface_AndroidSystem>> fStyles;
     SkString fFallbackFor;

     friend struct NameToFamily;
     friend class SkFontMgr_Android;

     using INHERITED = SkFontStyleSet;
 };

 /** On Android a single family can have many names, but our API assumes unique names.
  *  Map names to the back end so that all names for a given family refer to the same
  *  (non-replicated) set of typefaces.
  *  SkTDict<> doesn't let us do index-based lookup, so we write our own mapping.
  */
 struct NameToFamily {
     SkString name;
     SkFontStyleSet_Android* styleSet;
 };

 class SkFontMgr_Android : public SkFontMgr {
 public:
     SkFontMgr_Android(const SkFontMgr_Android_CustomFonts* custom) {
         SkTDArray<FontFamily*> families;
         if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem != custom->fSystemFontUse) {
             SkString base(custom->fBasePath);
             SkFontMgr_Android_Parser::GetCustomFontFamilies(
                 families, base, custom->fFontsXml, custom->fFallbackFontsXml);
         }
         if (!custom ||
             (custom && SkFontMgr_Android_CustomFonts::kOnlyCustom != custom->fSystemFontUse))
         {
             SkFontMgr_Android_Parser::GetSystemFontFamilies(families);
         }
         if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem == custom->fSystemFontUse) {
             SkString base(custom->fBasePath);
             SkFontMgr_Android_Parser::GetCustomFontFamilies(
                 families, base, custom->fFontsXml, custom->fFallbackFontsXml);
         }
         this->buildNameToFamilyMap(families, custom ? custom->fIsolated : false);
         this->findDefaultStyleSet();
         families.deleteAll();
     }

 protected:
     /** Returns not how many families we have, but how many unique names
      *  exist among the families.
      */
     int onCountFamilies() const override {
         return fNameToFamilyMap.count();
     }

     void onGetFamilyName(int index, SkString* familyName) const override {
         if (index < 0 || fNameToFamilyMap.count() <= index) {
             familyName->reset();
             return;
         }
         familyName->set(fNameToFamilyMap[index].name);
     }

     SkFontStyleSet* onCreateStyleSet(int index) const override {
         if (index < 0 || fNameToFamilyMap.count() <= index) {
             return nullptr;
         }
         return SkRef(fNameToFamilyMap[index].styleSet);
     }

     SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
         if (!familyName) {
             return nullptr;
         }
         SkAutoAsciiToLC tolc(familyName);
         for (int i = 0; i < fNameToFamilyMap.count(); ++i) {
             if (fNameToFamilyMap[i].name.equals(tolc.lc())) {
                 return SkRef(fNameToFamilyMap[i].styleSet);
             }
         }
         // TODO: eventually we should not need to name fallback families.
         for (int i = 0; i < fFallbackNameToFamilyMap.count(); ++i) {
             if (fFallbackNameToFamilyMap[i].name.equals(tolc.lc())) {
                 return SkRef(fFallbackNameToFamilyMap[i].styleSet);
             }
         }
         return nullptr;
     }

     SkTypeface* onMatchFamilyStyle(const char familyName[],
                                    const SkFontStyle& style) const override {
         sk_sp<SkFontStyleSet> sset(this->matchFamily(familyName));
         return sset->matchStyle(style);
     }

     SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
                                  const SkFontStyle& style) const override {
         for (int i = 0; i < fStyleSets.count(); ++i) {
             for (int j = 0; j < fStyleSets[i]->fStyles.count(); ++j) {
                 if (fStyleSets[i]->fStyles[j].get() == typeface) {
                     return fStyleSets[i]->matchStyle(style);
                 }
             }
         }
         return nullptr;
     }

     static sk_sp<SkTypeface_AndroidSystem> find_family_style_character(
             const SkString& familyName,
             const SkTArray<NameToFamily, true>& fallbackNameToFamilyMap,
             const SkFontStyle& style, bool elegant,
             const SkString& langTag, SkUnichar character)
     {
         for (int i = 0; i < fallbackNameToFamilyMap.count(); ++i) {
             SkFontStyleSet_Android* family = fallbackNameToFamilyMap[i].styleSet;
             if (familyName != family->fFallbackFor) {
                 continue;
             }
             sk_sp<SkTypeface_AndroidSystem> face(family->matchStyle(style));

             if (!langTag.isEmpty() &&
                 std::none_of(face->fLang.begin(), face->fLang.end(), [&](SkLanguage lang){
                     return lang.getTag().startsWith(langTag.c_str());
                 }))
             {
                 continue;
             }

             if (SkToBool(face->fVariantStyle & kElegant_FontVariant) != elegant) {
                 continue;
             }

             if (face->unicharToGlyph(character) != 0) {
                 return face;
             }
         }
         return nullptr;
     }

     SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
                                             const SkFontStyle& style,
                                             const char* bcp47[],
                                             int bcp47Count,
                                             SkUnichar character) const override {
         // The variant 'elegant' is 'not squashed', 'compact' is 'stays in ascent/descent'.
         // The variant 'default' means 'compact and elegant'.
         // As a result, it is not possible to know the variant context from the font alone.
         // TODO: add 'is_elegant' and 'is_compact' bits to 'style' request.

         SkString familyNameString(familyName);
         for (const SkString& currentFamilyName : { familyNameString, SkString() }) {
             // The first time match anything elegant, second time anything not elegant.
             for (int elegant = 2; elegant --> 0;) {
                 for (int bcp47Index = bcp47Count; bcp47Index --> 0;) {
                     SkLanguage lang(bcp47[bcp47Index]);
                     while (!lang.getTag().isEmpty()) {
                         sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
                             find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
                                                         style, SkToBool(elegant),
                                                         lang.getTag(), character);
                         if (matchingTypeface) {
                             return matchingTypeface.release();
                         }

                         lang = lang.getParent();
                     }
                 }
                 sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
                     find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
                                                 style, SkToBool(elegant),
                                                 SkString(), character);
                 if (matchingTypeface) {
                     return matchingTypeface.release();
                 }
             }
         }
         return nullptr;
     }

     sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData> data, int ttcIndex) const override {
         return this->makeFromStream(std::unique_ptr<SkStreamAsset>(new SkMemoryStream(std::move(data))),
                                     ttcIndex);
     }

     sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const override {
         std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(path);
         return stream ? this->makeFromStream(std::move(stream), ttcIndex) : nullptr;
     }

     sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset> stream,
                                             int ttcIndex) const override {
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         if (!fScanner.scanFont(stream.get(), ttcIndex, &name, &style, &isFixedPitch, nullptr)) {
             return nullptr;
         }
         auto data = std::make_unique<SkFontData>(std::move(stream), ttcIndex, nullptr, 0);
         return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
                                                               style, isFixedPitch, name));
     }

     sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> stream,
                                            const SkFontArguments& args) const override {
         using Scanner = SkTypeface_FreeType::Scanner;
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         Scanner::AxisDefinitions axisDefinitions;
         if (!fScanner.scanFont(stream.get(), args.getCollectionIndex(),
                                &name, &style, &isFixedPitch, &axisDefinitions))
         {
             return nullptr;
         }

         SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
         Scanner::computeAxisValues(axisDefinitions, args.getVariationDesignPosition(),
                                    axisValues, name);

         auto data = std::make_unique<SkFontData>(std::move(stream), args.getCollectionIndex(),
                                                    axisValues.get(), axisDefinitions.count());
         return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
                                                               style, isFixedPitch, name));
     }

     sk_sp<SkTypeface> onMakeFromFontData(std::unique_ptr<SkFontData> data) const override {
         SkStreamAsset* stream(data->getStream());
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
         if (!fScanner.scanFont(stream, data->getIndex(), &name, &style, &isFixedPitch, nullptr)) {
             return nullptr;
         }
         return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
                                                               style, isFixedPitch, name));
     }

     sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle style) const override {
         if (familyName) {
             // On Android, we must return nullptr when we can't find the requested
             // named typeface so that the system/app can provide their own recovery
             // mechanism. On other platforms we'd provide a typeface from the
             // default family instead.
             return sk_sp<SkTypeface>(this->onMatchFamilyStyle(familyName, style));
         }
         return sk_sp<SkTypeface>(fDefaultStyleSet->matchStyle(style));
     }


 private:

     SkTypeface_FreeType::Scanner fScanner;

     SkTArray<sk_sp<SkFontStyleSet_Android>> fStyleSets;
     sk_sp<SkFontStyleSet> fDefaultStyleSet;

     SkTArray<NameToFamily, true> fNameToFamilyMap;
     SkTArray<NameToFamily, true> fFallbackNameToFamilyMap;

     void addFamily(FontFamily& family, const bool isolated, int familyIndex) {
         SkTArray<NameToFamily, true>* nameToFamily = &fNameToFamilyMap;
         if (family.fIsFallbackFont) {
             nameToFamily = &fFallbackNameToFamilyMap;

             if (0 == family.fNames.count()) {
                 SkString& fallbackName = family.fNames.push_back();
                 fallbackName.printf("%.2x##fallback", familyIndex);
             }
         }

         sk_sp<SkFontStyleSet_Android> newSet =
             sk_make_sp<SkFontStyleSet_Android>(family, fScanner, isolated);
         if (0 == newSet->count()) {
             return;
         }

         for (const SkString& name : family.fNames) {
             nameToFamily->emplace_back(NameToFamily{name, newSet.get()});
         }
         fStyleSets.emplace_back(std::move(newSet));
     }
     void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const bool isolated) {
         int familyIndex = 0;
         for (FontFamily* family : families) {
             addFamily(*family, isolated, familyIndex++);
             family->fallbackFamilies.foreach([this, isolated, &familyIndex]
                 (SkString, std::unique_ptr<FontFamily>* fallbackFamily) {
                     addFamily(**fallbackFamily, isolated, familyIndex++);
                 }
             );
         }
     }

     void findDefaultStyleSet() {
         SkASSERT(!fStyleSets.empty());

         static const char* defaultNames[] = { "sans-serif" };
         for (const char* defaultName : defaultNames) {
             fDefaultStyleSet.reset(this->onMatchFamily(defaultName));
             if (fDefaultStyleSet) {
                 break;
             }
         }
         if (nullptr == fDefaultStyleSet) {
             fDefaultStyleSet = fStyleSets[0];
         }
         SkASSERT(fDefaultStyleSet);
     }

     using INHERITED = SkFontMgr;
 };

 #ifdef SK_DEBUG
 static char const * const gSystemFontUseStrings[] = {
     "OnlyCustom", "PreferCustom", "PreferSystem"
 };
 #endif

 sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom) {
     if (custom) {
         SkASSERT(0 <= custom->fSystemFontUse);
         SkASSERT(custom->fSystemFontUse < SK_ARRAY_COUNT(gSystemFontUseStrings));
         SkDEBUGF("SystemFontUse: %s BasePath: %s Fonts: %s FallbackFonts: %s\n",
                  gSystemFontUseStrings[custom->fSystemFontUse],
                  custom->fBasePath,
                  custom->fFontsXml,
                  custom->fFallbackFontsXml);
     }
     return sk_make_sp<SkFontMgr_Android>(custom);
 }
	/*
	* Copyright 2014 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "include/core/SkTypes.h"

	#include "include/core/SkData.h"
	#include "include/core/SkFontMgr.h"
	#include "include/core/SkFontStyle.h"
	#include "include/core/SkPaint.h"
	#include "include/core/SkRefCnt.h"
	#include "include/core/SkStream.h"
	#include "include/core/SkString.h"
	#include "include/ports/SkFontMgr_android.h"
	#include "include/private/SkFixed.h"
	#include "include/private/SkTArray.h"
	#include "include/private/SkTDArray.h"
	#include "include/private/SkTemplates.h"
	#include "src/core/SkFontDescriptor.h"
	#include "src/core/SkOSFile.h"
	#include "src/core/SkTSearch.h"
	#include "src/core/SkTypefaceCache.h"
	#include "src/ports/SkFontHost_FreeType_common.h"
	#include "src/ports/SkFontMgr_android_parser.h"

	#include <algorithm>
	#include <limits>

	class SkData;

	class SkTypeface_Android : public SkTypeface_FreeType {
	public:
	SkTypeface_Android(const SkFontStyle& style,
	bool isFixedPitch,
	const SkString& familyName)
	: INHERITED(style, isFixedPitch)
	, fFamilyName(familyName)
	{ }

	protected:
	void onGetFamilyName(SkString* familyName) const override {
	*familyName = fFamilyName;
	}

	SkString fFamilyName;

	private:
	using INHERITED = SkTypeface_FreeType;
	};

	class SkTypeface_AndroidSystem : public SkTypeface_Android {
	public:
	SkTypeface_AndroidSystem(const SkString& pathName,
	const bool cacheFontFiles,
	int index,
	const SkFixed* axes, int axesCount,
	const SkFontStyle& style,
	bool isFixedPitch,
	const SkString& familyName,
	const SkTArray<SkLanguage, true>& lang,
	FontVariant variantStyle)
	: INHERITED(style, isFixedPitch, familyName)
	, fPathName(pathName)
	, fIndex(index)
	, fAxes(axes, axesCount)
	, fLang(lang)
	, fVariantStyle(variantStyle)
	, fFile(cacheFontFiles ? sk_fopen(fPathName.c_str(), kRead_SkFILE_Flag) : nullptr) {
	if (cacheFontFiles) {
	SkASSERT(fFile);
	}
	}

	std::unique_ptr<SkStreamAsset> makeStream() const {
	if (fFile) {
	sk_sp<SkData> data(SkData::MakeFromFILE(fFile));
	return data ? std::make_unique<SkMemoryStream>(std::move(data)) : nullptr;
	}
	return SkStream::MakeFromFile(fPathName.c_str());
	}

	void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
	SkASSERT(desc);
	SkASSERT(serialize);
	desc->setFamilyName(fFamilyName.c_str());
	desc->setStyle(this->fontStyle());
	*serialize = false;
	}
	std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override {
	*ttcIndex = fIndex;
	return this->makeStream();
	}
	std::unique_ptr<SkFontData> onMakeFontData() const override {
	return std::make_unique<SkFontData>(this->makeStream(), fIndex,
	fAxes.begin(), fAxes.count());
	}
	sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
	std::unique_ptr<SkFontData> data = this->cloneFontData(args);
	if (!data) {
	return nullptr;
	}
	return sk_make_sp<SkTypeface_AndroidSystem>(fPathName,
	fFile,
	fIndex,
	data->getAxis(),
	data->getAxisCount(),
	this->fontStyle(),
	this->isFixedPitch(),
	fFamilyName,
	fLang,
	fVariantStyle);
	}

	const SkString fPathName;
	int fIndex;
	const SkSTArray<4, SkFixed, true> fAxes;
	const SkSTArray<4, SkLanguage, true> fLang;
	const FontVariant fVariantStyle;
	SkAutoTCallVProc<FILE, sk_fclose> fFile;

	using INHERITED = SkTypeface_Android;
	};

	class SkTypeface_AndroidStream : public SkTypeface_Android {
	public:
	SkTypeface_AndroidStream(std::unique_ptr<SkFontData> data,
	const SkFontStyle& style,
	bool isFixedPitch,
	const SkString& familyName)
	: INHERITED(style, isFixedPitch, familyName)
	, fData(std::move(data))
	{ }

	void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
	SkASSERT(desc);
	SkASSERT(serialize);
	desc->setFamilyName(fFamilyName.c_str());
	*serialize = true;
	}

	std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override {
	*ttcIndex = fData->getIndex();
	return fData->getStream()->duplicate();
	}

	std::unique_ptr<SkFontData> onMakeFontData() const override {
	return std::make_unique<SkFontData>(*fData);
	}

	sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {
	std::unique_ptr<SkFontData> data = this->cloneFontData(args);
	if (!data) {
	return nullptr;
	}
	return sk_make_sp<SkTypeface_AndroidStream>(std::move(data),
	this->fontStyle(),
	this->isFixedPitch(),
	fFamilyName);
	}

	private:
	const std::unique_ptr<const SkFontData> fData;
	using INHERITED = SkTypeface_Android;
	};

	class SkFontStyleSet_Android : public SkFontStyleSet {
	typedef SkTypeface_FreeType::Scanner Scanner;

	public:
	explicit SkFontStyleSet_Android(const FontFamily& family, const Scanner& scanner,
	const bool cacheFontFiles) {
	const SkString* cannonicalFamilyName = nullptr;
	if (family.fNames.count() > 0) {
	cannonicalFamilyName = &family.fNames[0];
	}
	fFallbackFor = family.fFallbackFor;

	// TODO? make this lazy
	for (int i = 0; i < family.fFonts.count(); ++i) {
	const FontFileInfo& fontFile = family.fFonts[i];

	SkString pathName(family.fBasePath);
	pathName.append(fontFile.fFileName);

	std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(pathName.c_str());
	if (!stream) {
	SkDEBUGF("Requested font file %s does not exist or cannot be opened.\n",
	pathName.c_str());
	continue;
	}

	const int ttcIndex = fontFile.fIndex;
	SkString familyName;
	SkFontStyle style;
	bool isFixedWidth;
	Scanner::AxisDefinitions axisDefinitions;
	if (!scanner.scanFont(stream.get(), ttcIndex,
	&familyName, &style, &isFixedWidth, &axisDefinitions))
	{
	SkDEBUGF("Requested font file %s exists, but is not a valid font.\n",
	pathName.c_str());
	continue;
	}

	int weight = fontFile.fWeight != 0 ? fontFile.fWeight : style.weight();
	SkFontStyle::Slant slant = style.slant();
	switch (fontFile.fStyle) {
	case FontFileInfo::Style::kAuto: slant = style.slant(); break;
	case FontFileInfo::Style::kNormal: slant = SkFontStyle::kUpright_Slant; break;
	case FontFileInfo::Style::kItalic: slant = SkFontStyle::kItalic_Slant; break;
	default: SkASSERT(false); break;
	}
	style = SkFontStyle(weight, style.width(), slant);

	uint32_t variant = family.fVariant;
	if (kDefault_FontVariant == variant) {
	variant = kCompact_FontVariant \| kElegant_FontVariant;
	}

	// The first specified family name overrides the family name found in the font.
	// TODO: SkTypeface_AndroidSystem::onCreateFamilyNameIterator should return
	// all of the specified family names in addition to the names found in the font.
	if (cannonicalFamilyName != nullptr) {
	familyName = *cannonicalFamilyName;
	}

	SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
	SkFontArguments::VariationPosition position = {
	fontFile.fVariationDesignPosition.begin(),
	fontFile.fVariationDesignPosition.count()
	};
	Scanner::computeAxisValues(axisDefinitions, position,
	axisValues, familyName);

	fStyles.push_back().reset(new SkTypeface_AndroidSystem(
	pathName, cacheFontFiles, ttcIndex, axisValues.get(), axisDefinitions.count(),
	style, isFixedWidth, familyName, family.fLanguages, variant));
	}
	}

	int count() override {
	return fStyles.count();
	}
	void getStyle(int index, SkFontStyle* style, SkString* name) override {
	if (index < 0 \|\| fStyles.count() <= index) {
	return;
	}
	if (style) {
	*style = fStyles[index]->fontStyle();
	}
	if (name) {
	name->reset();
	}
	}
	SkTypeface_AndroidSystem* createTypeface(int index) override {
	if (index < 0 \|\| fStyles.count() <= index) {
	return nullptr;
	}
	return SkRef(fStyles[index].get());
	}

	SkTypeface_AndroidSystem* matchStyle(const SkFontStyle& pattern) override {
	return static_cast<SkTypeface_AndroidSystem*>(this->matchStyleCSS3(pattern));
	}

	private:
	SkTArray<sk_sp<SkTypeface_AndroidSystem>> fStyles;
	SkString fFallbackFor;

	friend struct NameToFamily;
	friend class SkFontMgr_Android;

	using INHERITED = SkFontStyleSet;
	};

	/** On Android a single family can have many names, but our API assumes unique names.
	* Map names to the back end so that all names for a given family refer to the same
	* (non-replicated) set of typefaces.
	* SkTDict<> doesn't let us do index-based lookup, so we write our own mapping.
	*/
	struct NameToFamily {
	SkString name;
	SkFontStyleSet_Android* styleSet;
	};

	class SkFontMgr_Android : public SkFontMgr {
	public:
	SkFontMgr_Android(const SkFontMgr_Android_CustomFonts* custom) {
	SkTDArray<FontFamily*> families;
	if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem != custom->fSystemFontUse) {
	SkString base(custom->fBasePath);
	SkFontMgr_Android_Parser::GetCustomFontFamilies(
	families, base, custom->fFontsXml, custom->fFallbackFontsXml);
	}
	if (!custom \|\|
	(custom && SkFontMgr_Android_CustomFonts::kOnlyCustom != custom->fSystemFontUse))
	{
	SkFontMgr_Android_Parser::GetSystemFontFamilies(families);
	}
	if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem == custom->fSystemFontUse) {
	SkString base(custom->fBasePath);
	SkFontMgr_Android_Parser::GetCustomFontFamilies(
	families, base, custom->fFontsXml, custom->fFallbackFontsXml);
	}
	this->buildNameToFamilyMap(families, custom ? custom->fIsolated : false);
	this->findDefaultStyleSet();
	families.deleteAll();
	}

	protected:
	/** Returns not how many families we have, but how many unique names
	* exist among the families.
	*/
	int onCountFamilies() const override {
	return fNameToFamilyMap.count();
	}

	void onGetFamilyName(int index, SkString* familyName) const override {
	if (index < 0 \|\| fNameToFamilyMap.count() <= index) {
	familyName->reset();
	return;
	}
	familyName->set(fNameToFamilyMap[index].name);
	}

	SkFontStyleSet* onCreateStyleSet(int index) const override {
	if (index < 0 \|\| fNameToFamilyMap.count() <= index) {
	return nullptr;
	}
	return SkRef(fNameToFamilyMap[index].styleSet);
	}

	SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
	if (!familyName) {
	return nullptr;
	}
	SkAutoAsciiToLC tolc(familyName);
	for (int i = 0; i < fNameToFamilyMap.count(); ++i) {
	if (fNameToFamilyMap[i].name.equals(tolc.lc())) {
	return SkRef(fNameToFamilyMap[i].styleSet);
	}
	}
	// TODO: eventually we should not need to name fallback families.
	for (int i = 0; i < fFallbackNameToFamilyMap.count(); ++i) {
	if (fFallbackNameToFamilyMap[i].name.equals(tolc.lc())) {
	return SkRef(fFallbackNameToFamilyMap[i].styleSet);
	}
	}
	return nullptr;
	}

	SkTypeface* onMatchFamilyStyle(const char familyName[],
	const SkFontStyle& style) const override {
	sk_sp<SkFontStyleSet> sset(this->matchFamily(familyName));
	return sset->matchStyle(style);
	}

	SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
	const SkFontStyle& style) const override {
	for (int i = 0; i < fStyleSets.count(); ++i) {
	for (int j = 0; j < fStyleSets[i]->fStyles.count(); ++j) {
	if (fStyleSets[i]->fStyles[j].get() == typeface) {
	return fStyleSets[i]->matchStyle(style);
	}
	}
	}
	return nullptr;
	}

	static sk_sp<SkTypeface_AndroidSystem> find_family_style_character(
	const SkString& familyName,
	const SkTArray<NameToFamily, true>& fallbackNameToFamilyMap,
	const SkFontStyle& style, bool elegant,
	const SkString& langTag, SkUnichar character)
	{
	for (int i = 0; i < fallbackNameToFamilyMap.count(); ++i) {
	SkFontStyleSet_Android* family = fallbackNameToFamilyMap[i].styleSet;
	if (familyName != family->fFallbackFor) {
	continue;
	}
	sk_sp<SkTypeface_AndroidSystem> face(family->matchStyle(style));

	if (!langTag.isEmpty() &&
	std::none_of(face->fLang.begin(), face->fLang.end(), [&](SkLanguage lang){
	return lang.getTag().startsWith(langTag.c_str());
	}))
	{
	continue;
	}

	if (SkToBool(face->fVariantStyle & kElegant_FontVariant) != elegant) {
	continue;
	}

	if (face->unicharToGlyph(character) != 0) {
	return face;
	}
	}
	return nullptr;
	}

	SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
	const SkFontStyle& style,
	const char* bcp47[],
	int bcp47Count,
	SkUnichar character) const override {
	// The variant 'elegant' is 'not squashed', 'compact' is 'stays in ascent/descent'.
	// The variant 'default' means 'compact and elegant'.
	// As a result, it is not possible to know the variant context from the font alone.
	// TODO: add 'is_elegant' and 'is_compact' bits to 'style' request.

	SkString familyNameString(familyName);
	for (const SkString& currentFamilyName : { familyNameString, SkString() }) {
	// The first time match anything elegant, second time anything not elegant.
	for (int elegant = 2; elegant --> 0;) {
	for (int bcp47Index = bcp47Count; bcp47Index --> 0;) {
	SkLanguage lang(bcp47[bcp47Index]);
	while (!lang.getTag().isEmpty()) {
	sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
	find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
	style, SkToBool(elegant),
	lang.getTag(), character);
	if (matchingTypeface) {
	return matchingTypeface.release();
	}

	lang = lang.getParent();
	}
	}
	sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
	find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
	style, SkToBool(elegant),
	SkString(), character);
	if (matchingTypeface) {
	return matchingTypeface.release();
	}
	}
	}
	return nullptr;
	}

	sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData> data, int ttcIndex) const override {
	return this->makeFromStream(std::unique_ptr<SkStreamAsset>(new SkMemoryStream(std::move(data))),
	ttcIndex);
	}

	sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const override {
	std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(path);
	return stream ? this->makeFromStream(std::move(stream), ttcIndex) : nullptr;
	}

	sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset> stream,
	int ttcIndex) const override {
	bool isFixedPitch;
	SkFontStyle style;
	SkString name;
	if (!fScanner.scanFont(stream.get(), ttcIndex, &name, &style, &isFixedPitch, nullptr)) {
	return nullptr;
	}
	auto data = std::make_unique<SkFontData>(std::move(stream), ttcIndex, nullptr, 0);
	return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
	style, isFixedPitch, name));
	}

	sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> stream,
	const SkFontArguments& args) const override {
	using Scanner = SkTypeface_FreeType::Scanner;
	bool isFixedPitch;
	SkFontStyle style;
	SkString name;
	Scanner::AxisDefinitions axisDefinitions;
	if (!fScanner.scanFont(stream.get(), args.getCollectionIndex(),
	&name, &style, &isFixedPitch, &axisDefinitions))
	{
	return nullptr;
	}

	SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
	Scanner::computeAxisValues(axisDefinitions, args.getVariationDesignPosition(),
	axisValues, name);

	auto data = std::make_unique<SkFontData>(std::move(stream), args.getCollectionIndex(),
	axisValues.get(), axisDefinitions.count());
	return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
	style, isFixedPitch, name));
	}

	sk_sp<SkTypeface> onMakeFromFontData(std::unique_ptr<SkFontData> data) const override {
	SkStreamAsset* stream(data->getStream());
	bool isFixedPitch;
	SkFontStyle style;
	SkString name;
	if (!fScanner.scanFont(stream, data->getIndex(), &name, &style, &isFixedPitch, nullptr)) {
	return nullptr;
	}
	return sk_sp<SkTypeface>(new SkTypeface_AndroidStream(std::move(data),
	style, isFixedPitch, name));
	}

	sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle style) const override {
	if (familyName) {
	// On Android, we must return nullptr when we can't find the requested
	// named typeface so that the system/app can provide their own recovery
	// mechanism. On other platforms we'd provide a typeface from the
	// default family instead.
	return sk_sp<SkTypeface>(this->onMatchFamilyStyle(familyName, style));
	}
	return sk_sp<SkTypeface>(fDefaultStyleSet->matchStyle(style));
	}


	private:

	SkTypeface_FreeType::Scanner fScanner;

	SkTArray<sk_sp<SkFontStyleSet_Android>> fStyleSets;
	sk_sp<SkFontStyleSet> fDefaultStyleSet;

	SkTArray<NameToFamily, true> fNameToFamilyMap;
	SkTArray<NameToFamily, true> fFallbackNameToFamilyMap;

	void addFamily(FontFamily& family, const bool isolated, int familyIndex) {
	SkTArray<NameToFamily, true>* nameToFamily = &fNameToFamilyMap;
	if (family.fIsFallbackFont) {
	nameToFamily = &fFallbackNameToFamilyMap;

	if (0 == family.fNames.count()) {
	SkString& fallbackName = family.fNames.push_back();
	fallbackName.printf("%.2x##fallback", familyIndex);
	}
	}

	sk_sp<SkFontStyleSet_Android> newSet =
	sk_make_sp<SkFontStyleSet_Android>(family, fScanner, isolated);
	if (0 == newSet->count()) {
	return;
	}

	for (const SkString& name : family.fNames) {
	nameToFamily->emplace_back(NameToFamily{name, newSet.get()});
	}
	fStyleSets.emplace_back(std::move(newSet));
	}
	void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const bool isolated) {
	int familyIndex = 0;
	for (FontFamily* family : families) {
	addFamily(*family, isolated, familyIndex++);
	family->fallbackFamilies.foreach([this, isolated, &familyIndex]
	(SkString, std::unique_ptr<FontFamily>* fallbackFamily) {
	addFamily(**fallbackFamily, isolated, familyIndex++);
	}
	);
	}
	}

	void findDefaultStyleSet() {
	SkASSERT(!fStyleSets.empty());

	static const char* defaultNames[] = { "sans-serif" };
	for (const char* defaultName : defaultNames) {
	fDefaultStyleSet.reset(this->onMatchFamily(defaultName));
	if (fDefaultStyleSet) {
	break;
	}
	}
	if (nullptr == fDefaultStyleSet) {
	fDefaultStyleSet = fStyleSets[0];
	}
	SkASSERT(fDefaultStyleSet);
	}

	using INHERITED = SkFontMgr;
	};

	#ifdef SK_DEBUG
	static char const * const gSystemFontUseStrings[] = {
	"OnlyCustom", "PreferCustom", "PreferSystem"
	};
	#endif

	sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom) {
	if (custom) {
	SkASSERT(0 <= custom->fSystemFontUse);
	SkASSERT(custom->fSystemFontUse < SK_ARRAY_COUNT(gSystemFontUseStrings));
	SkDEBUGF("SystemFontUse: %s BasePath: %s Fonts: %s FallbackFonts: %s\n",
	gSystemFontUseStrings[custom->fSystemFontUse],
	custom->fBasePath,
	custom->fFontsXml,
	custom->fFallbackFontsXml);
	}
	return sk_make_sp<SkFontMgr_Android>(custom);
	}