diff options
Diffstat (limited to 'native/android/system_fonts.cpp')
| -rw-r--r-- | native/android/system_fonts.cpp | 339 |
1 files changed, 339 insertions, 0 deletions
diff --git a/native/android/system_fonts.cpp b/native/android/system_fonts.cpp new file mode 100644 index 000000000000..4d3d1d66ffda --- /dev/null +++ b/native/android/system_fonts.cpp @@ -0,0 +1,339 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <jni.h> + +#include <android/system_fonts.h> + +#include <memory> +#include <string> +#include <vector> + +#include <errno.h> +#include <fcntl.h> +#include <libxml/tree.h> +#include <log/log.h> +#include <sys/stat.h> +#include <unistd.h> + +#include <hwui/MinikinSkia.h> +#include <minikin/FontCollection.h> +#include <minikin/LocaleList.h> +#include <minikin/SystemFonts.h> + +struct XmlCharDeleter { + void operator()(xmlChar* b) { xmlFree(b); } +}; + +struct XmlDocDeleter { + void operator()(xmlDoc* d) { xmlFreeDoc(d); } +}; + +using XmlCharUniquePtr = std::unique_ptr<xmlChar, XmlCharDeleter>; +using XmlDocUniquePtr = std::unique_ptr<xmlDoc, XmlDocDeleter>; + +struct ASystemFontIterator { + XmlDocUniquePtr mXmlDoc; + xmlNode* mFontNode; + + // The OEM customization XML. + XmlDocUniquePtr mCustomizationXmlDoc; +}; + +struct ASystemFont { + std::string mFilePath; + std::unique_ptr<std::string> mLocale; + uint16_t mWeight; + bool mItalic; + uint32_t mCollectionIndex; + std::vector<std::pair<uint32_t, float>> mAxes; +}; + +namespace { + +std::string xmlTrim(const std::string& in) { + if (in.empty()) { + return in; + } + const char XML_SPACES[] = "\u0020\u000D\u000A\u0009"; + const size_t start = in.find_first_not_of(XML_SPACES); // inclusive + if (start == std::string::npos) { + return ""; + } + const size_t end = in.find_last_not_of(XML_SPACES); // inclusive + if (end == std::string::npos) { + return ""; + } + return in.substr(start, end - start + 1 /* +1 since end is inclusive */); +} + +const xmlChar* FAMILY_TAG = BAD_CAST("family"); +const xmlChar* FONT_TAG = BAD_CAST("font"); + +xmlNode* firstElement(xmlNode* node, const xmlChar* tag) { + for (xmlNode* child = node->children; child; child = child->next) { + if (xmlStrEqual(child->name, tag)) { + return child; + } + } + return nullptr; +} + +xmlNode* nextSibling(xmlNode* node, const xmlChar* tag) { + while ((node = node->next) != nullptr) { + if (xmlStrEqual(node->name, tag)) { + return node; + } + } + return nullptr; +} + +void copyFont(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode, ASystemFont* out, + const std::string& pathPrefix) { + const xmlChar* LOCALE_ATTR_NAME = BAD_CAST("lang"); + XmlCharUniquePtr filePathStr( + xmlNodeListGetString(xmlDoc.get(), fontNode->xmlChildrenNode, 1)); + out->mFilePath = pathPrefix + xmlTrim( + std::string(filePathStr.get(), filePathStr.get() + xmlStrlen(filePathStr.get()))); + + const xmlChar* WEIGHT_ATTR_NAME = BAD_CAST("weight"); + XmlCharUniquePtr weightStr(xmlGetProp(fontNode, WEIGHT_ATTR_NAME)); + out->mWeight = weightStr ? + strtol(reinterpret_cast<const char*>(weightStr.get()), nullptr, 10) : 400; + + const xmlChar* STYLE_ATTR_NAME = BAD_CAST("style"); + const xmlChar* ITALIC_ATTR_VALUE = BAD_CAST("italic"); + XmlCharUniquePtr styleStr(xmlGetProp(fontNode, STYLE_ATTR_NAME)); + out->mItalic = styleStr ? xmlStrEqual(styleStr.get(), ITALIC_ATTR_VALUE) : false; + + const xmlChar* INDEX_ATTR_NAME = BAD_CAST("index"); + XmlCharUniquePtr indexStr(xmlGetProp(fontNode, INDEX_ATTR_NAME)); + out->mCollectionIndex = indexStr ? + strtol(reinterpret_cast<const char*>(indexStr.get()), nullptr, 10) : 0; + + XmlCharUniquePtr localeStr(xmlGetProp(xmlDoc->parent, LOCALE_ATTR_NAME)); + out->mLocale.reset( + localeStr ? new std::string(reinterpret_cast<const char*>(localeStr.get())) : nullptr); + + const xmlChar* TAG_ATTR_NAME = BAD_CAST("tag"); + const xmlChar* STYLEVALUE_ATTR_NAME = BAD_CAST("stylevalue"); + const xmlChar* AXIS_TAG = BAD_CAST("axis"); + out->mAxes.clear(); + for (xmlNode* axis = firstElement(fontNode, AXIS_TAG); axis; + axis = nextSibling(axis, AXIS_TAG)) { + XmlCharUniquePtr tagStr(xmlGetProp(axis, TAG_ATTR_NAME)); + if (!tagStr || xmlStrlen(tagStr.get()) != 4) { + continue; // Tag value must be 4 char string + } + + XmlCharUniquePtr styleValueStr(xmlGetProp(axis, STYLEVALUE_ATTR_NAME)); + if (!styleValueStr) { + continue; + } + + uint32_t tag = + static_cast<uint32_t>(tagStr.get()[0] << 24) | + static_cast<uint32_t>(tagStr.get()[1] << 16) | + static_cast<uint32_t>(tagStr.get()[2] << 8) | + static_cast<uint32_t>(tagStr.get()[3]); + float styleValue = strtod(reinterpret_cast<const char*>(styleValueStr.get()), nullptr); + out->mAxes.push_back(std::make_pair(tag, styleValue)); + } +} + +bool isFontFileAvailable(const std::string& filePath) { + std::string fullPath = filePath; + struct stat st = {}; + if (stat(fullPath.c_str(), &st) != 0) { + return false; + } + return S_ISREG(st.st_mode); +} + +xmlNode* findFirstFontNode(const XmlDocUniquePtr& doc) { + xmlNode* familySet = xmlDocGetRootElement(doc.get()); + if (familySet == nullptr) { + return nullptr; + } + xmlNode* family = firstElement(familySet, FAMILY_TAG); + if (family == nullptr) { + return nullptr; + } + + xmlNode* font = firstElement(family, FONT_TAG); + while (font == nullptr) { + family = nextSibling(family, FAMILY_TAG); + if (family == nullptr) { + return nullptr; + } + font = firstElement(family, FONT_TAG); + } + return font; +} + +} // namespace + +ASystemFontIterator* ASystemFontIterator_open() { + std::unique_ptr<ASystemFontIterator> ite(new ASystemFontIterator()); + ite->mXmlDoc.reset(xmlReadFile("/system/etc/fonts.xml", nullptr, 0)); + ite->mCustomizationXmlDoc.reset(xmlReadFile("/product/etc/fonts_customization.xml", nullptr, 0)); + return ite.release(); +} + +void ASystemFontIterator_close(ASystemFontIterator* ite) { + delete ite; +} + +ASystemFont* ASystemFont_matchFamilyStyleCharacter( + const char* _Nonnull familyName, + uint16_t weight, + bool italic, + const char* _Nonnull languageTags, + const uint16_t* _Nonnull text, + uint32_t textLength, + uint32_t* _Nullable runLength) { + std::shared_ptr<minikin::FontCollection> fc = + minikin::SystemFonts::findFontCollection(familyName); + std::vector<minikin::FontCollection::Run> runs = + fc->itemize(minikin::U16StringPiece(text, textLength), + minikin::FontStyle(weight, static_cast<minikin::FontStyle::Slant>(italic)), + minikin::registerLocaleList(languageTags), + minikin::FamilyVariant::DEFAULT); + + const minikin::Font* font = runs[0].fakedFont.font; + std::unique_ptr<ASystemFont> result = std::make_unique<ASystemFont>(); + const android::MinikinFontSkia* minikinFontSkia = + reinterpret_cast<android::MinikinFontSkia*>(font->typeface().get()); + result->mFilePath = minikinFontSkia->getFilePath(); + result->mWeight = font->style().weight(); + result->mItalic = font->style().slant() == minikin::FontStyle::Slant::ITALIC; + result->mCollectionIndex = minikinFontSkia->GetFontIndex(); + const std::vector<minikin::FontVariation>& axes = minikinFontSkia->GetAxes(); + result->mAxes.reserve(axes.size()); + for (auto axis : axes) { + result->mAxes.push_back(std::make_pair(axis.axisTag, axis.value)); + } + if (runLength != nullptr) { + *runLength = runs[0].end; + } + return result.release(); +} + +xmlNode* findNextFontNode(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode) { + if (fontNode == nullptr) { + if (!xmlDoc) { + return nullptr; // Already at the end. + } else { + // First time to query font. + return findFirstFontNode(xmlDoc); + } + } else { + xmlNode* nextNode = nextSibling(fontNode, FONT_TAG); + while (nextNode == nullptr) { + xmlNode* family = nextSibling(fontNode->parent, FAMILY_TAG); + if (family == nullptr) { + break; + } + nextNode = firstElement(family, FONT_TAG); + } + return nextNode; + } +} + +ASystemFont* ASystemFontIterator_next(ASystemFontIterator* ite) { + LOG_ALWAYS_FATAL_IF(ite == nullptr, "nullptr has passed as iterator argument"); + if (ite->mXmlDoc) { + ite->mFontNode = findNextFontNode(ite->mXmlDoc, ite->mFontNode); + if (ite->mFontNode == nullptr) { + // Reached end of the XML file. Continue OEM customization. + ite->mXmlDoc.reset(); + ite->mFontNode = nullptr; + } else { + std::unique_ptr<ASystemFont> font = std::make_unique<ASystemFont>(); + copyFont(ite->mXmlDoc, ite->mFontNode, font.get(), "/system/fonts/"); + if (!isFontFileAvailable(font->mFilePath)) { + return ASystemFontIterator_next(ite); + } + return font.release(); + } + } + if (ite->mCustomizationXmlDoc) { + // TODO: Filter only customizationType="new-named-family" + ite->mFontNode = findNextFontNode(ite->mCustomizationXmlDoc, ite->mFontNode); + if (ite->mFontNode == nullptr) { + // Reached end of the XML file. Finishing + ite->mCustomizationXmlDoc.reset(); + ite->mFontNode = nullptr; + return nullptr; + } else { + std::unique_ptr<ASystemFont> font = std::make_unique<ASystemFont>(); + copyFont(ite->mCustomizationXmlDoc, ite->mFontNode, font.get(), "/product/fonts/"); + if (!isFontFileAvailable(font->mFilePath)) { + return ASystemFontIterator_next(ite); + } + return font.release(); + } + } + return nullptr; +} + +void ASystemFont_close(ASystemFont* font) { + delete font; +} + +const char* ASystemFont_getFontFilePath(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); + return font->mFilePath.c_str(); +} + +uint16_t ASystemFont_getWeight(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); + return font->mWeight; +} + +bool ASystemFont_isItalic(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument"); + return font->mItalic; +} + +const char* ASystemFont_getLocale(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); + return font->mLocale ? nullptr : font->mLocale->c_str(); +} + +size_t ASystemFont_getCollectionIndex(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); + return font->mCollectionIndex; +} + +size_t ASystemFont_getAxisCount(const ASystemFont* font) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); + return font->mAxes.size(); +} + +uint32_t ASystemFont_getAxisTag(const ASystemFont* font, uint32_t axisIndex) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); + LOG_ALWAYS_FATAL_IF(axisIndex >= font->mAxes.size(), + "given axis index is out of bounds. (< %zd", font->mAxes.size()); + return font->mAxes[axisIndex].first; +} + +float ASystemFont_getAxisValue(const ASystemFont* font, uint32_t axisIndex) { + LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument"); + LOG_ALWAYS_FATAL_IF(axisIndex >= font->mAxes.size(), + "given axis index is out of bounds. (< %zd", font->mAxes.size()); + return font->mAxes[axisIndex].second; +} |