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

Commit 20866c14 authored by Seigo Nonaka's avatar Seigo Nonaka
Browse files

Use enum class for FontVariation and update MinikinUtils 

This CL contains followins:
- Use enum class FontVariation instead of legacy enum.
- Store FontStyle in MinikinPaint.

Bug: 65024629
Test: minikin_tests
Change-Id: I86bf64fd5d9a8c08eff47db851fa4655da84b1e4
parent b10dd415

core/jni/android/graphics/FontFamily.cpp

+10 −8
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include <hwui/Typeface.h>

#include <utils/FatVector.h>

#include <minikin/FontFamily.h>

#include <minikin/LocaleList.h>



#include <memory>
@@ -43,9 +44,10 @@ namespace android { 


struct NativeFamilyBuilder {

    NativeFamilyBuilder(uint32_t langId, int variant)

        : langId(langId), variant(variant), allowUnsupportedFont(false) {}

        : langId(langId), variant(static_cast<minikin::FontVariant>(variant)),

          allowUnsupportedFont(false) {}

    uint32_t langId;

    int variant;

    minikin::FontVariant variant;

    bool allowUnsupportedFont;

    std::vector<minikin::Font> fonts;

    std::vector<minikin::FontVariation> axes;
@@ -55,10 +57,9 @@ static jlong FontFamily_initBuilder(JNIEnv* env, jobject clazz, jstring langs, j 
    NativeFamilyBuilder* builder;

    if (langs != nullptr) {

        ScopedUtfChars str(env, langs);

        builder = new NativeFamilyBuilder(

                minikin::FontStyle::registerLocaleList(str.c_str()), variant);

        builder = new NativeFamilyBuilder(minikin::registerLocaleList(str.c_str()), variant);

    } else {

        builder = new NativeFamilyBuilder(minikin::FontStyle::registerLocaleList(""), variant);

        builder = new NativeFamilyBuilder(minikin::registerLocaleList(""), variant);

    }

    return reinterpret_cast<jlong>(builder);

}
@@ -121,14 +122,14 @@ static bool addSkTypeface(NativeFamilyBuilder* builder, sk_sp<SkData>&& data, in 
            std::make_shared<MinikinFontSkia>(std::move(face), fontPtr, fontSize, ttcIndex,

                    builder->axes);



    int weight = givenWeight / 100;

    int weight = givenWeight;

    bool italic = givenItalic == 1;

    if (givenWeight == RESOLVE_BY_FONT_TABLE || givenItalic == RESOLVE_BY_FONT_TABLE) {

        int os2Weight;

        bool os2Italic;

        if (!minikin::FontFamily::analyzeStyle(minikinFont, &os2Weight, &os2Italic)) {

            ALOGE("analyzeStyle failed. Using default style");

            os2Weight = 4;

            os2Weight = 400;

            os2Italic = false;

        }

        if (givenWeight == RESOLVE_BY_FONT_TABLE) {
@@ -139,7 +140,8 @@ static bool addSkTypeface(NativeFamilyBuilder* builder, sk_sp<SkData>&& data, in 
        }

    }



    builder->fonts.push_back(minikin::Font(minikinFont, minikin::FontStyle(weight, italic)));

    builder->fonts.push_back(minikin::Font(minikinFont,

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

    builder->axes.clear();

    return true;

}

core/jni/android/graphics/Paint.cpp

+12 −11
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ 
#include <hwui/Paint.h>

#include <hwui/Typeface.h>

#include <minikin/GraphemeBreak.h>

#include <minikin/LocaleList.h>

#include <minikin/Measurement.h>

#include <unicode/utf16.h>
@@ -546,9 +547,9 @@ namespace PaintGlue { 
    static jint setTextLocales(JNIEnv* env, jobject clazz, jlong objHandle, jstring locales) {

        Paint* obj = reinterpret_cast<Paint*>(objHandle);

        ScopedUtfChars localesChars(env, locales);

        jint minikinLangListId = minikin::FontStyle::registerLocaleList(localesChars.c_str());

        obj->setMinikinLangListId(minikinLangListId);

        return minikinLangListId;

        jint minikinLocaleListId = minikin::registerLocaleList(localesChars.c_str());

        obj->setMinikinLocaleListId(minikinLocaleListId);

        return minikinLocaleListId;

    }



    static void setFontFeatureSettings(JNIEnv* env, jobject clazz, jlong paintHandle, jstring settings) {
@@ -580,7 +581,7 @@ namespace PaintGlue { 
        // restore the original settings.

        paint->setTextSkewX(saveSkewX);

        paint->setFakeBoldText(savefakeBold);

        if (paint->getFontVariant() == minikin::VARIANT_ELEGANT) {

        if (paint->getFontVariant() == minikin::FontVariant::ELEGANT) {

            SkScalar size = paint->getTextSize();

            metrics->fTop = -size * kElegantTop / 2048;

            metrics->fBottom = -size * kElegantBottom / 2048;
@@ -871,20 +872,20 @@ namespace PaintGlue { 
        obj->setTextAlign(align);

    }



    static void setTextLocalesByMinikinLangListId(jlong objHandle,

            jint minikinLangListId) {

    static void setTextLocalesByMinikinLocaleListId(jlong objHandle,

            jint minikinLocaleListId) {

        Paint* obj = reinterpret_cast<Paint*>(objHandle);

        obj->setMinikinLangListId(minikinLangListId);

        obj->setMinikinLocaleListId(minikinLocaleListId);

    }



    static jboolean isElegantTextHeight(jlong paintHandle) {

        Paint* obj = reinterpret_cast<Paint*>(paintHandle);

        return obj->getFontVariant() == minikin::VARIANT_ELEGANT;

        return obj->getFontVariant() == minikin::FontVariant::ELEGANT;

    }



    static void setElegantTextHeight(jlong paintHandle, jboolean aa) {

        Paint* obj = reinterpret_cast<Paint*>(paintHandle);

        obj->setFontVariant(aa ? minikin::VARIANT_ELEGANT : minikin::VARIANT_DEFAULT);

        obj->setFontVariant(aa ? minikin::FontVariant::ELEGANT : minikin::FontVariant::DEFAULT);

    }



    static jfloat getTextSize(jlong paintHandle) {
@@ -1080,8 +1081,8 @@ static const JNINativeMethod methods[] = { 
    {"nSetTypeface","(JJ)V", (void*) PaintGlue::setTypeface},

    {"nGetTextAlign","(J)I", (void*) PaintGlue::getTextAlign},

    {"nSetTextAlign","(JI)V", (void*) PaintGlue::setTextAlign},

    {"nSetTextLocalesByMinikinLangListId","(JI)V",

            (void*) PaintGlue::setTextLocalesByMinikinLangListId},

    {"nSetTextLocalesByMinikinLocaleListId","(JI)V",

            (void*) PaintGlue::setTextLocalesByMinikinLocaleListId},

    {"nIsElegantTextHeight","(J)Z", (void*) PaintGlue::isElegantTextHeight},

    {"nSetElegantTextHeight","(JZ)V", (void*) PaintGlue::setElegantTextHeight},

    {"nGetTextSize","(J)F", (void*) PaintGlue::getTextSize},

core/jni/android/graphics/Typeface.cpp

+1 −1
Original line number Diff line number Diff line
@@ -83,7 +83,7 @@ static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) { 


static jint Typeface_getWeight(JNIEnv* env, jobject obj, jlong faceHandle) {

    Typeface* face = reinterpret_cast<Typeface*>(faceHandle);

    return face->fStyle.getWeight() * 100;

    return face->fStyle.weight;

}



static jlong Typeface_createFromArray(JNIEnv *env, jobject, jlongArray familyArray,

core/jni/android_text_StaticLayout.cpp

+9 −18
Original line number Diff line number Diff line
@@ -126,19 +126,17 @@ class Run { 
class StyleRun : public Run {

    public:

        StyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,

                std::shared_ptr<minikin::FontCollection>&& collection,

                minikin::FontStyle&& style, bool isRtl)

                std::shared_ptr<minikin::FontCollection>&& collection, bool isRtl)

            : Run(start, end), mPaint(std::move(paint)), mCollection(std::move(collection)),

              mStyle(std::move(style)), mIsRtl(isRtl) {}

              mIsRtl(isRtl) {}



        void addTo(minikin::LineBreaker* lineBreaker) override {

            lineBreaker->addStyleRun(&mPaint, mCollection, mStyle, mStart, mEnd, mIsRtl);

            lineBreaker->addStyleRun(&mPaint, mCollection, mStart, mEnd, mIsRtl);

        }



    private:

        minikin::MinikinPaint mPaint;

        std::shared_ptr<minikin::FontCollection> mCollection;

        minikin::FontStyle mStyle;

        const bool mIsRtl;

};
@@ -167,10 +165,9 @@ class StaticLayoutNative { 
              mRightPaddings(std::move(rightPaddings)) {}



        void addStyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,

                         std::shared_ptr<minikin::FontCollection> collection,

                         minikin::FontStyle&& style, bool isRtl) {

                         std::shared_ptr<minikin::FontCollection> collection, bool isRtl) {

            mRuns.emplace_back(std::make_unique<StyleRun>(

                    start, end, std::move(paint), std::move(collection), std::move(style), isRtl));

                    start, end, std::move(paint), std::move(collection), isRtl));

        }



        void addReplacementRun(int32_t start, int32_t end, float width, uint32_t localeListId) {
@@ -323,15 +320,9 @@ static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr, 
static void nAddStyleRun(jlong nativePtr, jlong nativePaint, jint start, jint end, jboolean isRtl) {

    StaticLayoutNative* builder = toNative(nativePtr);

    Paint* paint = reinterpret_cast<Paint*>(nativePaint);

    const Typeface* typeface = paint->getAndroidTypeface();

    minikin::MinikinPaint minikinPaint;

    const Typeface* resolvedTypeface = Typeface::resolveDefault(typeface);

    minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, paint,

            typeface);



    builder->addStyleRun(

        start, end, std::move(minikinPaint), resolvedTypeface->fFontCollection, std::move(style),

        isRtl);

    const Typeface* typeface = Typeface::resolveDefault(paint->getAndroidTypeface());

    minikin::MinikinPaint minikinPaint = MinikinUtils::prepareMinikinPaint(paint, typeface);

    builder->addStyleRun(start, end, std::move(minikinPaint), typeface->fFontCollection, isRtl);

}



// CriticalNative
@@ -339,7 +330,7 @@ static void nAddReplacementRun(jlong nativePtr, jlong nativePaint, jint start, j 
        jfloat width) {

    StaticLayoutNative* builder = toNative(nativePtr);

    Paint* paint = reinterpret_cast<Paint*>(nativePaint);

    builder->addReplacementRun(start, end, width, paint->getMinikinLangListId());

    builder->addReplacementRun(start, end, width, paint->getMinikinLocaleListId());

}



static const JNINativeMethod gMethods[] = {

graphics/java/android/graphics/Paint.java

+8 −8
Original line number Diff line number Diff line
@@ -88,7 +88,7 @@ public class Paint { 
     * A map from a string representation of the LocaleList to Minikin's language list ID.

     */

    @GuardedBy("sCacheLock")

    private static final HashMap<String, Integer> sMinikinLangListIdCache = new HashMap<>();

    private static final HashMap<String, Integer> sMinikinLocaleListIdCache = new HashMap<>();



    /**

     * @hide
@@ -1445,16 +1445,16 @@ public class Paint { 


    private void syncTextLocalesWithMinikin() {

        final String languageTags = mLocales.toLanguageTags();

        final Integer minikinLangListId;

        final Integer minikinLocaleListId;

        synchronized (sCacheLock) {

            minikinLangListId = sMinikinLangListIdCache.get(languageTags);

            if (minikinLangListId == null) {

            minikinLocaleListId = sMinikinLocaleListIdCache.get(languageTags);

            if (minikinLocaleListId == null) {

                final int newID = nSetTextLocales(mNativePaint, languageTags);

                sMinikinLangListIdCache.put(languageTags, newID);

                sMinikinLocaleListIdCache.put(languageTags, newID);

                return;

            }

        }

        nSetTextLocalesByMinikinLangListId(mNativePaint, minikinLangListId.intValue());

        nSetTextLocalesByMinikinLocaleListId(mNativePaint, minikinLocaleListId.intValue());

    }



    /**
@@ -2918,8 +2918,8 @@ public class Paint { 
    @CriticalNative

    private static native void nSetTextAlign(long paintPtr, int align);

    @CriticalNative

    private static native void nSetTextLocalesByMinikinLangListId(long paintPtr,

            int mMinikinLangListId);

    private static native void nSetTextLocalesByMinikinLocaleListId(long paintPtr,

            int mMinikinLocaleListId);

    @CriticalNative

    private static native void nSetShadowLayer(long paintPtr,

            float radius, float dx, float dy, int color);