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

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

Merge "Use enum class for FontVariation and update MinikinUtils"

parents 483e54ae 20866c14

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