Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 055d58ae authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Update the system font implementation for new API change"

parents 7a8aac1e b3a7bcea

native/android/libandroid.map.txt

+15 −10
Original line number Diff line number Diff line
@@ -248,16 +248,21 @@ LIBANDROID { 
    ASystemFontIterator_open; # introduced=29

    ASystemFontIterator_close; # introduced=29

    ASystemFontIterator_next; # introduced=29

    ASystemFont_close; # introduced=29

    ASystemFont_getFontFilePath; # introduced=29

    ASystemFont_getWeight; # introduced=29

    ASystemFont_isItalic; # introduced=29

    ASystemFont_getLocale; # introduced=29

    ASystemFont_getCollectionIndex; # introduced=29

    ASystemFont_getAxisCount; # introduced=29

    ASystemFont_getAxisTag; # introduced=29

    ASystemFont_getAxisValue; # introduced=29

    ASystemFont_matchFamilyStyleCharacter; # introduced=29

    AFont_close; # introduced=29

    AFont_getFontFilePath; # introduced=29

    AFont_getWeight; # introduced=29

    AFont_isItalic; # introduced=29

    AFont_getLocale; # introduced=29

    AFont_getCollectionIndex; # introduced=29

    AFont_getAxisCount; # introduced=29

    AFont_getAxisTag; # introduced=29

    AFont_getAxisValue; # introduced=29

    AFontMatcher_create; # introduced=29

    AFontMatcher_destroy; # introduced=29

    AFontMatcher_setStyle; # introduced=29

    AFontMatcher_setLocales; # introduced=29

    AFontMatcher_setFamilyVariant; # introduced=29

    AFontMatcher_match; # introduced=29

    ATrace_beginSection; # introduced=23

    ATrace_endSection; # introduced=23

    ATrace_isEnabled; # introduced=23

native/android/system_fonts.cpp

+64 −25
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 


#include <jni.h>



#include <android/font.h>

#include <android/font_matcher.h>

#include <android/system_fonts.h>



#include <memory>
@@ -53,7 +55,7 @@ struct ASystemFontIterator { 
    XmlDocUniquePtr mCustomizationXmlDoc;

};



struct ASystemFont {

struct AFont {

    std::string mFilePath;

    std::unique_ptr<std::string> mLocale;

    uint16_t mWeight;
@@ -62,6 +64,19 @@ struct ASystemFont { 
    std::vector<std::pair<uint32_t, float>> mAxes;

};



struct AFontMatcher {

    minikin::FontStyle mFontStyle;

    uint32_t mLocaleListId = 0;  // 0 is reserved for empty locale ID.

    bool mFamilyVariant = AFAMILY_VARIANT_DEFAULT;

};



static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_DEFAULT) ==

              static_cast<uint32_t>(minikin::FamilyVariant::DEFAULT));

static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_COMPACT) ==

              static_cast<uint32_t>(minikin::FamilyVariant::COMPACT));

static_assert(static_cast<uint32_t>(AFAMILY_VARIANT_ELEGANT) ==

              static_cast<uint32_t>(minikin::FamilyVariant::ELEGANT));



namespace {



std::string xmlTrim(const std::string& in) {
@@ -101,7 +116,7 @@ xmlNode* nextSibling(xmlNode* node, const xmlChar* tag) { 
    return nullptr;

}



void copyFont(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode, ASystemFont* out,

void copyFont(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode, AFont* out,

              const std::string& pathPrefix) {

    const xmlChar* LOCALE_ATTR_NAME = BAD_CAST("lang");

    XmlCharUniquePtr filePathStr(
@@ -197,24 +212,48 @@ void ASystemFontIterator_close(ASystemFontIterator* ite) { 
    delete ite;

}



ASystemFont* ASystemFont_matchFamilyStyleCharacter(

        const char* _Nonnull familyName,

AFontMatcher* _Nonnull AFontMatcher_create() {

    return new AFontMatcher();

}



void AFontMatcher_destroy(AFontMatcher* matcher) {

    delete matcher;

}



void AFontMatcher_setStyle(

        AFontMatcher* _Nonnull matcher,

        uint16_t weight,

        bool italic,

        const char* _Nonnull languageTags,

        bool italic) {

    matcher->mFontStyle = minikin::FontStyle(

            weight, static_cast<minikin::FontStyle::Slant>(italic));

}



void AFontMatcher_setLocales(

        AFontMatcher* _Nonnull matcher,

        const char* _Nonnull languageTags) {

    matcher->mLocaleListId = minikin::registerLocaleList(languageTags);

}



void AFontMatcher_setFamilyVariant(AFontMatcher* _Nonnull matcher, uint32_t familyVariant) {

    matcher->mFamilyVariant = familyVariant;

}



AFont* _Nonnull AFontMatcher_match(

        const AFontMatcher* _Nonnull matcher,

        const char* _Nonnull familyName,

        const uint16_t* _Nonnull text,

        uint32_t textLength,

        const 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);

    std::vector<minikin::FontCollection::Run> runs = fc->itemize(

                minikin::U16StringPiece(text, textLength),

                matcher->mFontStyle,

                matcher->mLocaleListId,

                static_cast<minikin::FamilyVariant>(matcher->mFamilyVariant));



    const minikin::Font* font = runs[0].fakedFont.font;

    std::unique_ptr<ASystemFont> result = std::make_unique<ASystemFont>();

    std::unique_ptr<AFont> result = std::make_unique<AFont>();

    const android::MinikinFontSkia* minikinFontSkia =

            reinterpret_cast<android::MinikinFontSkia*>(font->typeface().get());

    result->mFilePath = minikinFontSkia->getFilePath();
@@ -253,7 +292,7 @@ xmlNode* findNextFontNode(const XmlDocUniquePtr& xmlDoc, xmlNode* fontNode) { 
    }

}



ASystemFont* ASystemFontIterator_next(ASystemFontIterator* ite) {

AFont* 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);
@@ -262,7 +301,7 @@ ASystemFont* ASystemFontIterator_next(ASystemFontIterator* ite) { 
            ite->mXmlDoc.reset();

            ite->mFontNode = nullptr;

        } else {

            std::unique_ptr<ASystemFont> font = std::make_unique<ASystemFont>();

            std::unique_ptr<AFont> font = std::make_unique<AFont>();

            copyFont(ite->mXmlDoc, ite->mFontNode, font.get(), "/system/fonts/");

            if (!isFontFileAvailable(font->mFilePath)) {

                return ASystemFontIterator_next(ite);
@@ -279,7 +318,7 @@ ASystemFont* ASystemFontIterator_next(ASystemFontIterator* ite) { 
            ite->mFontNode = nullptr;

            return nullptr;

        } else {

            std::unique_ptr<ASystemFont> font = std::make_unique<ASystemFont>();

            std::unique_ptr<AFont> font = std::make_unique<AFont>();

            copyFont(ite->mCustomizationXmlDoc, ite->mFontNode, font.get(), "/product/fonts/");

            if (!isFontFileAvailable(font->mFilePath)) {

                return ASystemFontIterator_next(ite);
@@ -290,48 +329,48 @@ ASystemFont* ASystemFontIterator_next(ASystemFontIterator* ite) { 
    return nullptr;

}



void ASystemFont_close(ASystemFont* font) {

void AFont_close(AFont* font) {

    delete font;

}



const char* ASystemFont_getFontFilePath(const ASystemFont* font) {

const char* AFont_getFontFilePath(const AFont* 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) {

uint16_t AFont_getWeight(const AFont* font) {

    LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument");

    return font->mWeight;

}



bool ASystemFont_isItalic(const ASystemFont* font) {

bool AFont_isItalic(const AFont* font) {

    LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed as font argument");

    return font->mItalic;

}



const char* ASystemFont_getLocale(const ASystemFont* font) {

const char* AFont_getLocale(const AFont* 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) {

size_t AFont_getCollectionIndex(const AFont* font) {

    LOG_ALWAYS_FATAL_IF(font == nullptr, "nullptr has passed to font argument");

    return font->mCollectionIndex;

}



size_t ASystemFont_getAxisCount(const ASystemFont* font) {

size_t AFont_getAxisCount(const AFont* 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) {

uint32_t AFont_getAxisTag(const AFont* 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) {

float AFont_getAxisValue(const AFont* 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());