text: /*
   * 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);
  }
  