@hxa-rn/react-native-gcanvas 6.0.24-beta.1

package/harmony/gcanvas/src/main/cpp/core/src/platform/ohos/GFontCache.h

@@ -0,0 +1,94 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef __GCanvas__GFontCache__
+#define __GCanvas__GFontCache__
+
+#include "GFont.h"
+#include <iostream>
+#include <map>
+#include <queue>
+#include <string>
+
+
+class GCanvas2DContextHarmony;
+
+
+class GFont;
+namespace gcanvas
+{
+    class GFontStyle;
+}
+
+struct GFontSet
+{
+    GFont *font = nullptr;
+    GFont *fallbackFont = nullptr;
+};
+
+class GFontManager;
+
+class GFontCache
+{
+public:
+    GFontCache(GFontManager& fontManager);
+
+
+    ~GFontCache();
+
+#ifdef GFONT_LOAD_BY_FREETYPE
+
+    GFont *GetOrCreateFont(GCanvasContext *context, const std::string contextId,
+                           gcanvas::GFontStyle *fontStyle, wchar_t charCode, const float size);
+    GFont *GetOrCreateEmojiFont(GCanvasContext *context, const std::string contextId,
+                                gcanvas::GFontStyle *fontStyle, wchar_t charCode, const float size);
+
+#else
+    GFont *GetOrCreateFont(const std::string &key);
+#endif
+
+    void ReadyToRemoveCacheForFonts(
+            const std::map<GFont *, std::vector<wchar_t> > &fontsToBeDeleted, bool isStroke);
+
+    void RemoveCacheForFonts(
+            const std::map<GFont *, std::vector<wchar_t> > &fontsToBeDeleted, bool isStroke);
+
+private:
+
+    void clear();
+
+    bool LoadFace(FT_Library *library, const char *filename, const float size,
+                  FT_Face *face);
+
+    char *TryDefaultFont(const wchar_t charCode, const float size,
+                         const char *currentFontLocation);
+
+    char *TryDefaultFallbackFont(const wchar_t charCode, const float size,
+                                 const char *currentFontLocation);
+
+    char *TryDefaultEmojiFont(const wchar_t charCode, const float size,
+                              const char *currentFontLocation);
+
+    char *TryOtherFallbackFont(GCanvasContext *context, const wchar_t charCode, const float size,
+                               const char *currentFontLocation, gcanvas::GFontStyle *fontStyle);
+
+    char *TrySpecFont(const wchar_t charCode, const float size,
+                      const char *currentFontLocation,
+                      const char *specFontFile);
+
+    bool IsGlyphExistedInFont(const wchar_t charCode, const float size,
+                              const std::string &filename);
+
+private:
+    GFontManager& mFontManager;
+    std::map<std::string, GFontSet> mFontCache;
+    std::queue<std::map<GFont *, std::vector<wchar_t> > > mCachedPages;
+};
+
+#endif
+

package/harmony/gcanvas/src/main/cpp/core/src/platform/ohos/GFontFamily.cpp

@@ -0,0 +1,188 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include <ctype.h>
+#include <support/Log.h>
+
+#include "GFontFamily.h"
+
+namespace gcanvas
+{
+    GFontFamilyItem::GFontFamilyItem() {
+
+        font_file_name = nullptr;
+
+        style = GFontStyle::Style::NORMAL;
+
+        variant = GFontStyle::Variant::NORMAL;
+
+        weight = GFontStyle::Weight::NORMAL;
+
+    }
+    GFontFamily::GFontFamily(std::list< const char * > &fontFamily)
+    {
+        matchFontFamily(fontFamily);
+    }
+
+    const char *GFontFamily::MatchFamilyStyle(GFontStyle &fontStyle) {
+
+        GFontStyle::Style style = fontStyle.GetStyle();
+        GFontStyle::Weight weight = fontStyle.GetWeight();
+        GFontStyle::Variant variant = fontStyle.GetVariant();
+
+        // web属性收敛
+        // Android内oblique与italic一样
+        if (style == GFontStyle::Style::OBLIQUE) {
+            style = GFontStyle::Style::ITALIC;
+        }
+
+        if (weight == GFontStyle::Weight::BOLDER || weight == GFontStyle::Weight::EXTRA_BOLD
+            || weight == GFontStyle::Weight::SEMI_BOLD) {
+            weight = GFontStyle::Weight::BOLD;
+        } else if (weight == GFontStyle::Weight::LIGHTER || weight == GFontStyle::Weight::EXTRA_LIGHT) {
+            weight = GFontStyle::Weight::LIGHT;
+        }
+
+        // LOG_E("match fontStyle begin %s", fontStyle.GetFullFontStyle().data());
+
+        GFontFamilyItem* closetItem = nullptr;
+        for (auto it = fontItems.begin(); it != fontItems.end(); ++it) {
+            GFontFamilyItem* item = &(*it);
+            if (item->style == style) {
+                if (closetItem == nullptr) { // 选择首个style匹配的item
+                    closetItem = item;
+                }
+                if (item->weight == weight) { // style & weight 都匹配的item
+                    closetItem = item;
+                    if (item->variant == variant) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (closetItem != nullptr) {
+            // LOG_E("match fontStyle (%s) = file (%s) ", fontStyle.GetFullFontStyle().data(), closetItem->font_file_name);
+            return closetItem->font_file_name;
+        }
+
+        // LOG_E("match fontStyle (%s) = file (%s) ", fontStyle.GetFullFontStyle().data(), result);
+        return "";
+    }
+
+
+    /**
+     * 将xml中的font名称 转化为font family item
+     */
+    void GFontFamily::matchFontFamily(std::list<const char *> &fontFamily) {
+        fontItems.clear();
+
+        // style
+        const char *style_italic = "italic";
+        // const char *style_oblique = "oblique";
+
+        // variant
+        const char *var_smallcaps = "smallcaps";
+
+        // weight（lighter,bolder,extra-light,extra-bold等不支持)
+        const char *weight_thin = "thin";
+        const char *weight_light = "light";
+        const char *weight_regular = "regular";
+        const char *weight_medium = "medium";
+        const char *weight_bold = "bold";
+        const char *weight_black = "black";
+
+
+        GFontFamilyItem* item;
+        for (auto it = fontFamily.begin(); it != fontFamily.end(); ++it) {
+            int length = strlen(*it);
+            char *fontFileLowerCase = new char[length + 1];
+            strcpy(fontFileLowerCase, *it);
+
+            for (int i = 0; i < length; ++i) {
+                fontFileLowerCase[i] = tolower(fontFileLowerCase[i]);
+            }
+
+            // 字符串比较方式
+            item = new GFontFamilyItem();
+            if (strstr(fontFileLowerCase, style_italic) != nullptr) {
+                item->style = GFontStyle::Style::ITALIC;
+            }
+
+            if (strstr(fontFileLowerCase, var_smallcaps) != nullptr) {
+                item->variant = GFontStyle::Variant::SMALL_CAPS;
+            }
+
+            if (strstr(fontFileLowerCase, weight_thin) != nullptr) {
+                item->weight = GFontStyle::Weight::THIN;
+            } else if (strstr(fontFileLowerCase, weight_light) != nullptr) {
+                item->weight = GFontStyle::Weight::LIGHT;
+            } else if (strstr(fontFileLowerCase, weight_regular) != nullptr) {
+                item->weight = GFontStyle::Weight::NORMAL;
+            } else if (strstr(fontFileLowerCase, weight_medium) != nullptr) {
+                item->weight = GFontStyle::Weight::MEDIUM;
+            } else if (strstr(fontFileLowerCase, weight_bold) != nullptr) {
+                item->weight = GFontStyle::Weight::BOLD;
+            } else if (strstr(fontFileLowerCase, weight_black) != nullptr) {
+                item->weight = GFontStyle::Weight::BLACK;
+            }
+
+            item->font_file_name = *it;
+
+            fontItems.push_back(std::move(*item));
+
+            delete[] fontFileLowerCase;
+        }
+    }
+
+    void GFontFamily::matchFontFamilyLegacy(std::list<const char *> &fontFamily) {
+        const char *italic = "italic";
+        const char *bold = "bold";
+        const char *light = "light";
+        for (auto it = fontFamily.begin(); it != fontFamily.end(); ++it) {
+            int length = strlen(*it);
+            char *fontFileLowerCase = new char[length + 1];
+            strcpy(fontFileLowerCase, *it);
+            for (int i = 0; i < length; ++i) {
+                fontFileLowerCase[i] = tolower(fontFileLowerCase[i]);
+            }
+
+            if (strstr(fontFileLowerCase, bold) != nullptr) {
+                if (strstr(fontFileLowerCase, italic) != nullptr) {
+                    this->mFontBoldItalic = *it;
+                } else {
+                    this->mFontBold = *it;
+                }
+            } else if (strstr(fontFileLowerCase, italic)) {
+                this->mFontItalic = *it;
+            } else if (strstr(fontFileLowerCase, light)) {
+                this->mFontLight = *it;
+            } else {
+                this->mFontNormal = *it;
+            }
+
+            delete[] fontFileLowerCase;
+        }
+    }
+
+
+    char *GFontFamily::GetProperFontFile() {
+
+        GFontFamilyItem* closetItem = nullptr;
+        if(fontItems.size() > 0) {
+            closetItem = &fontItems[0];
+        }
+        if (closetItem != nullptr) {
+            return (char *)closetItem->font_file_name;
+        }
+
+        static char defaultFont[] = "NotoSansCJK-Regular.ttc";
+        return defaultFont;
+    }
+
+}

package/harmony/gcanvas/src/main/cpp/core/src/platform/ohos/GFontFamily.h

@@ -0,0 +1,69 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#ifndef __GCanvas_GFontFamily__
+#define __GCanvas_GFontFamily__
+
+#include "GFontStyle.h"
+
+#include <export.h>
+#include <vector>
+
+namespace gcanvas
+{
+
+
+    /**
+     * font family内的单个字体
+     */
+    struct GFontFamilyItem {
+
+        const char* font_file_name;
+
+        GFontStyle::Style style;
+
+        GFontStyle::Variant variant;
+
+        GFontStyle::Weight  weight;
+
+
+        GFontFamilyItem();
+
+    };
+
+
+
+class GFontFamily
+{
+public:
+    GFontFamily(std::list< const char * > &fontFamily);
+    virtual ~GFontFamily() {}
+
+    API_EXPORT const char *MatchFamilyStyle(GFontStyle &fontStyle);
+    char *GetProperFontFile();
+
+private:
+    void matchFontFamily(std::list<const char *> &fontFamily);
+
+    void matchFontFamilyLegacy(std::list<const char *> &fontFamily);
+
+
+    // @depreated
+    const char *mFontNormal= nullptr;
+    const char *mFontLight= nullptr;
+    const char *mFontBold= nullptr;
+    const char *mFontItalic= nullptr;
+    const char *mFontBoldItalic= nullptr;
+
+    std::vector<GFontFamilyItem> fontItems;
+
+    };
+}
+
+#endif
+

package/harmony/gcanvas/src/main/cpp/core/src/platform/ohos/GFontManagerHarmony.cpp

@@ -0,0 +1,329 @@
+/**
+ * Created by G-Canvas Open Source Team.
+ * Copyright (c) 2017, Alibaba, Inc. All rights reserved.
+ *
+ * This source code is licensed under the Apache Licence 2.0.
+ * For the full copyright and license information, please view
+ * the LICENSE file in the root directory of this source tree.
+ */
+#include "GFont.h"
+#include "GCanvas.hpp"
+#include "GFontCache.h"
+#include "support/CharacterSet.h"
+#include "GFontManagerHarmony.h"
+#include "GCanvas2DContextHarmony.h"
+#include "gcanvas/GFontManager.h"
+#include "gcanvas/GCanvas2dContext.h"
+#include "support/Log.h"
+#include "support/CharacterSet.h"
+#include "gcanvas/GTextDefine.h"
+
+#include <assert.h>
+GFontManagerHarmony::GFontManagerHarmony(GCanvasContext *context) : GFontManager(context) {
+
+}
+
+
+GFontManagerHarmony::~GFontManagerHarmony() {
+    mTreemap.Clear();
+    mGlyphCache.ClearGlyphsTexture();
+}
+
+
+void GFontManagerHarmony::DrawText(const unsigned int *ucs,
+                                   unsigned int ucsLength, float x, float y,
+                                   bool isStroke, gcanvas::GFontStyle *fontStyle) {
+    if (ucs == nullptr || ucsLength == 0) {
+        return;
+    }
+    std::vector<GFont *> fonts;
+
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (isCharcodeEmoji(ucs, ucsLength, i)) {
+            fonts.push_back(GetEmojiFont(ucs[i], fontStyle));
+
+            // need this at the first glance to make sure the mFace of the first
+            // emoji after a text is not nullptr when the first emoji run GetSizeRatio()
+            fonts[i]->GetGlyph(ucs[i], isStroke);
+        } else {
+            fonts.push_back(GetFontByCharCode(ucs[i], fontStyle));
+        }
+    }
+
+    AdjustTextPenPoint(fonts, ucs, ucsLength, isStroke, x, y);
+
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (ucs[i] == UCS4_EMOJI_SELECTOR ||
+            ucs[i] == UCS4_TEXT_SELECTOR ||
+            ucs[i] == UCS4_ZERO_WIDTH_JOINER
+        ) {
+            continue;
+        }
+
+        if (i < ucsLength - 2 && ucs[i + 2] == UCS4_COMBINING_ENCLOSING_KEYCAP) {
+            // ref to (U+0031 U+FE0F U+20E3) in https://projects.iamcal.com/emoji-data/table.htm
+            FillTextInternal(fonts[i + 2], isStroke, ucs[i + 2], x, y);
+            FillTextInternal(fonts[i], isStroke, ucs[i], x, y);
+            i += 2;
+        } else {
+            FillTextInternal(fonts[i], isStroke, ucs[i], x, y);
+        }
+    }
+}
+
+
+float *GFontManagerHarmony::MeasureTextWidthHeight(const char *text, unsigned int textLength,
+                                                   gcanvas::GFontStyle *fontStyle) {
+    if (text == nullptr || textLength == 0) {
+        float *ret = new float[4];
+        ret[0] = ret[1] = ret[2] = ret[3] = 0.0;
+        return ret;
+    }
+    LOG_D("MeasureTextWidthHeight text=%s,textLength=%d",text,textLength);
+    Utf8ToUCS4 *lbData = new Utf8ToUCS4(text, textLength);
+    unsigned int *ucs = lbData->ucs4;
+    unsigned int ucsLength = lbData->ucs4len;
+
+    std::vector<GFont *> fonts;
+
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (isCharcodeEmoji(ucs, ucsLength, i)) {
+            fonts.push_back(GetEmojiFont(ucs[i], fontStyle));
+        } else {
+            fonts.push_back(GetFontByCharCode(ucs[i], fontStyle));
+        }
+    }
+
+    float deltaX = 0;
+    float maxHeight = 0;
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (ucs[i] == UCS4_EMOJI_SELECTOR ||
+            ucs[i] == UCS4_TEXT_SELECTOR ||
+            ucs[i] == UCS4_ZERO_WIDTH_JOINER ||
+            ucs[i] == UCS4_COMBINING_ENCLOSING_KEYCAP
+        ) {
+            continue;
+        }
+
+        auto glyph = fonts[i]->GetGlyph(ucs[i], false);
+
+        if (glyph != nullptr) {
+            deltaX += fonts[i]->GetSizeRatio() * glyph->advanceX / mContext->mCurrentState->mscaleFontX;
+        }
+    }
+
+    if (fonts.size() > 0) {
+        //文本高度本来应该去除上下空白的，但是laya1，还是有点问题，所以这个高度，还是用老的高度ascender+descender绝对�?       
+         maxHeight = fabs(fonts[0]->GetSizeRatio() * fonts[0]->GetMetrics()->ascender / mContext->mCurrentState->mscaleFontY) +
+         fabs(fonts[0]->GetSizeRatio() * fonts[0]->GetMetrics()->descender / mContext->mCurrentState->mscaleFontY);
+    }
+
+    //如果满足条件则，返回不带空白的文字高�?   
+    float m_ascender = mContext->mCurrentState->mFont->GetAscender();
+    float m_descender = mContext->mCurrentState->mFont->GetDescender();
+    if (m_ascender > 0 && m_descender > 0) {
+        maxHeight = m_ascender + m_descender;
+    }
+
+    delete lbData;
+
+    float *ret = new float[4];
+    ret[0] = deltaX;
+    ret[1] = maxHeight;
+    ret[2] = m_ascender;
+    ret[3] = m_descender;
+    return ret;
+}
+
+float GFontManagerHarmony::MeasureText(const char *text,
+                                       unsigned int textLength, gcanvas::GFontStyle *fontStyle) {
+    float *tmpMeasure = MeasureTextWidthHeight(text, textLength, fontStyle);
+    float width = tmpMeasure[0];
+    delete tmpMeasure;
+    return width;
+}
+
+
+float *GFontManagerHarmony::MeasureTextExt(const char *text, unsigned int textLength,
+                                           gcanvas::GFontStyle *fontStyle) {
+    float *tmpMeasure = MeasureTextWidthHeight(text, textLength, fontStyle);
+    return tmpMeasure;
+}
+
+float *GFontManagerHarmony::PreMeasureTextHeight(const char *text,
+                                                 unsigned int textLength,
+                                                 gcanvas::GFontStyle *fontStyle) {
+    if (text == nullptr || textLength == 0) {
+        float *ret = new float[4];
+        ret[0] = ret[1] = ret[2] = ret[3] = 0.0;
+        return ret;
+    }
+
+    Utf8ToUCS4 *lbData = new Utf8ToUCS4(text, textLength);
+
+    unsigned int *ucs = lbData->ucs4;
+    unsigned int ucsLength = lbData->ucs4len;
+
+    std::vector<GFont *> fonts;
+
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (isCharcodeEmoji(ucs, ucsLength, i)) {
+            fonts.push_back(GetEmojiFont(ucs[i], fontStyle));
+        } else {
+            fonts.push_back(GetFontByCharCode(ucs[i], fontStyle));
+        }
+    }
+
+    float top = 0;
+    float height = 0;
+    float ascender = 0;
+    float descender = 0;
+    for (unsigned int i = 0; i < ucsLength; ++i) {
+        if (ucs[i] == UCS4_EMOJI_SELECTOR ||
+            ucs[i] == UCS4_TEXT_SELECTOR ||
+            ucs[i] == UCS4_ZERO_WIDTH_JOINER ||
+            ucs[i] == UCS4_COMBINING_ENCLOSING_KEYCAP
+        ) {
+            continue;
+        }
+
+        auto glyph = fonts[i]->GetGlyph(ucs[i], false);
+
+        if (glyph != nullptr) {
+            top = glyph->offsetY / mContext->mCurrentState->mscaleFontY;
+            height = glyph->height / mContext->mCurrentState->mscaleFontY;
+            ascender = fonts[i]->GetSizeRatio() * fonts[i]->GetMetrics()->ascender / mContext->mCurrentState->mscaleFontY;
+            descender = fonts[0]->GetSizeRatio() * fonts[0]->GetMetrics()->descender / mContext->mCurrentState->mscaleFontY;
+        }
+    }
+
+    delete lbData;
+
+    float *ret = new float[4];
+    ret[0] = top;
+    ret[1] = height;
+    ret[2] = ascender;
+    ret[3] = descender;
+    return ret;
+}
+
+void GFontManagerHarmony::AdjustTextPenPoint(std::vector<GFont *> fonts,
+                                             const unsigned int *ucs,
+                                             unsigned int ucsLength,
+                                             bool isStroke,
+        /*out*/ float &x,
+        /*out*/ float &y) {
+    if (mContext->mCurrentState->mTextAlign != GTextAlign::GTEXT_ALIGN_START &&
+        mContext->mCurrentState->mTextAlign != GTextAlign::GTEXT_ALIGN_LEFT) {
+        auto left_x = x;
+        auto delta_x = 0.0f;
+        for (unsigned int i = 0; i < ucsLength; ++i) {
+            if (ucs[i] == UCS4_EMOJI_SELECTOR ||
+                ucs[i] == UCS4_TEXT_SELECTOR ||
+                ucs[i] == UCS4_ZERO_WIDTH_JOINER ||
+                ucs[i] == UCS4_COMBINING_ENCLOSING_KEYCAP
+            ) {
+                continue;
+            }
+
+            auto glyph = fonts[i]->GetGlyph(ucs[i], isStroke);
+
+            if (glyph != nullptr) {
+                delta_x += fonts[i]->GetSizeRatio() * glyph->advanceX / mContext->mCurrentState->mscaleFontX;
+            }
+        }
+
+        if (mContext->mCurrentState->mTextAlign == GTextAlign::GTEXT_ALIGN_CENTER) {
+            x = left_x - delta_x / 2.0f;
+        } else // textAlign is "Right" or "End"
+        {
+            x = left_x - delta_x;
+        }
+    }
+
+    GFont *font0 = fonts[0];
+    font0->GetGlyph(ucs[0], isStroke);
+    auto font_metrics = font0->GetMetrics();
+    auto size_ratio = font0->GetSizeRatio();
+    auto ascender = size_ratio * font_metrics->ascender / mContext->mCurrentState->mscaleFontY;
+    auto descender = size_ratio * font_metrics->descender / mContext->mCurrentState->mscaleFontY;
+
+    //m_ascender，m_descender不能除scale，因为在PreMeasureTextHeight获取这两个值时，已经除过了
+    float m_ascender = mContext->mCurrentState->mFont->GetAscender();
+    float m_descender = mContext->mCurrentState->mFont->GetDescender();
+
+    switch (mContext->mCurrentState->mTextBaseline) {
+        case GTEXT_BASELINE_TOP:
+        case GTEXT_BASELINE_HANGING:
+            if (m_ascender > 0 && m_descender > 0) {
+                y += fabs(m_ascender);
+            } else {
+                y += fabs(ascender);
+            }
+            break;
+        case GGTEXT_BASELINE_BOTTOM:
+        case GTEXT_BASELINE_IDEOGRAPHIC:
+            if (m_ascender > 0 && m_descender > 0) {
+                y -= fabs(m_descender);
+            } else {
+                y -= fabs(descender);
+            }
+            break;
+        case GTEXT_BASELINE_MIDDLE:
+            if (m_ascender > 0 && m_descender > 0) {
+                y += (fabs(m_ascender) - fabs(m_descender)) / 2.0f;
+            } else {
+                y += (fabs(ascender) - fabs(descender)) / 2.0f;
+            }
+            break;
+        case GTEXT_BASELINE_ALPHABETIC:
+        default:
+            break;
+    }
+
+}
+
+
+GFont *GFontManagerHarmony::GetFontByCharCode(wchar_t charCode, gcanvas::GFontStyle *fontStyle) {
+    float devicePixelRatio = 1;
+    if (mContext->GetHiQuality()) {
+        devicePixelRatio = mContext->mDevicePixelRatio;
+    }
+    float size = fontStyle->GetSize() * devicePixelRatio;
+     LOG_D("GetFontByCharCode devicePixelRatio:%f",devicePixelRatio);
+    GFont *font = mFontCache->GetOrCreateFont(mContext,
+                                              mContext->mContextId,
+                                              fontStyle, charCode, size);
+    return font;
+}
+
+GFont *GFontManagerHarmony::GetEmojiFont(wchar_t charCode, gcanvas::GFontStyle *fontStyle) {
+    float devicePixelRatio = 1;
+    if (mContext->GetHiQuality()) {
+        devicePixelRatio = mContext->mDevicePixelRatio;
+    }
+    float size = fontStyle->GetSize() * devicePixelRatio;
+
+    GFont *font = mFontCache->GetOrCreateEmojiFont(mContext,
+                                                   mContext->mContextId,
+                                                   fontStyle, charCode, size);
+    return font;
+}
+
+void GFontManagerHarmony::FillTextInternal(GFont *font, bool isStroke, wchar_t charcode,
+                                           float &x, float y) {
+    float sizeRatio = font->GetSizeRatio();
+
+    if (isStroke) {
+        font->DrawText(charcode, mContext, x, y, mContext->StrokeStyle(), isStroke, sizeRatio);
+
+    } else {
+        font->DrawText(charcode, mContext, x, y, mContext->FillStyle(), isStroke, sizeRatio);
+
+    }
+}
+
+void GFontManagerHarmony::SetFontCache(GFontCache *fontCache) {
+    this->mFontCache = fontCache;
+}
+