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

package/harmony/gcanvas/src/main/cpp/core/src/GCanvasWeex.cpp

@@ -0,0 +1,1925 @@
+/**
+ * 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.
+ */
+#ifdef GCANVAS_WEEX
+
+#include "gcanvas/GShaderManager.h"
+#include "GCanvasManager.h"
+#include "GCanvasWeex.hpp"
+#include "GCanvas2dContext.h"
+#include "support/Encode.h"
+#include "support/Util.h"
+
+#include <stdio.h>
+
+#ifdef ANDROID
+#include "platform/Android/GCanvas2DContextAndroid.h"
+#elif defined(OHOS)
+#include "platform/ohos/GCanvas2DContextHarmony.h"
+#else
+#include <sys/time.h>
+#endif
+
+namespace gcanvas {
+
+GCanvasWeex::GCanvasWeex(std::string contextId, const GCanvasConfig &config) :
+        GCanvas(contextId, config) {
+    mCurrentTransform = GTransformIdentity,
+            mFrames = 0;
+    mFps = 0.0f;
+    mContextLost = false;
+    mResult = "";
+#if defined (ANDROID) || defined (OHOS) 
+    sem_init(&mCallNative, 0, 1);
+    sem_init(&mSyncSem, 0, 0);
+#endif
+}
+
+GCanvasWeex::~GCanvasWeex() {
+    clearCmdQueue();
+#if defined(ANDROID) || defined(OHOS)
+    sem_destroy(&mCallNative);
+    sem_destroy(&mSyncSem);
+#endif
+}
+
+void GCanvasWeex::CreateContext() {
+#ifdef ANDROID
+    mCanvasContext = new GCanvas2DContextAndroid(0, 0, mConfig);
+#elif defined(OHOS)
+    mCanvasContext = new GCanvas2DContextHarmony(0, 0, mConfig);
+#else
+    mCanvasContext = new GCanvasContext(0, 0, mConfig);
+#endif
+    mCanvasContext->mContextId = this->mContextId;
+}
+
+void GCanvasWeex::ReCreateContext() {
+    delete mCanvasContext;
+    CreateContext();
+}
+
+void GCanvasWeex::Clear() {
+    LOG_D("GCanvasWeex::DoContextLost start.");
+    // No need to clean up GL memory with glDeleteBuffers or glDeleteTextures.
+    // It all gets blown away automatically when the context is lost.
+    mContextLost = true;
+    mTextureMgr.Clear();
+#if defined (ANDROID) || defined (OHOS) 
+    clearCmdQueue();
+#endif
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    LOG_D("GCanvasWeex::DoContextLost end.");
+}
+
+
+void GCanvasWeex::SetClearColor(const GColorRGBA &c) {
+    mCanvasContext->SetClearColor(c);
+}
+
+void GCanvasWeex::SetDevicePixelRatio(const float ratio) {
+    mCanvasContext->SetDevicePixelRatio(ratio);
+}
+
+bool GCanvasWeex::ImageSmoothingEnabled() {
+    return mCanvasContext->ImageSmoothingEnabled();
+}
+
+void GCanvasWeex::SetImageSmoothingEnabled(bool smooth) {
+    mCanvasContext->SetImageSmoothingEnabled(smooth);
+}
+
+int GCanvasWeex::GetContextType() {
+    return mCanvasContext->mContextType;
+}
+
+void GCanvasWeex::SetContextType(int contextType) {
+    mCanvasContext->mContextType = contextType;
+}
+
+GTexture *GCanvasWeex::GetFboTexture() {
+    return mCanvasContext->GetFboTexture();
+}
+
+
+//GCanvas Weex
+void GCanvasWeex::SetOrtho(int width, int height) {
+}
+
+void GCanvasWeex::SetTyOffsetFlag(bool flag) {
+}
+
+void GCanvasWeex::AddTexture(int textureGroupId, int glID, int width, int height) {
+    LOG_D("AddTexture, Group ID = %d, GL ID = %d, width = %d, height = %d, context lost = %d",
+          textureGroupId, glID, width, height, mContextLost);
+    if (mContextLost) return;
+    mTextureMgr.Append(textureGroupId, glID, width, height);
+}
+
+#ifdef IOS
+void GCanvasWeex::AddOfflineTexture(int textureGroupId, int glID){
+    if (mContextLost) return;
+
+    std::map< int, int >::iterator iter = mOfflineTextures.find(glID);
+    if (iter == mOfflineTextures.end())
+    {
+        mOfflineTextures.insert( std::pair< int, int >(textureGroupId, glID) );
+    }
+}
+#endif
+
+bool GCanvasWeex::AddPngTexture(const unsigned char *buffer, unsigned int size, int textureGroupId,
+                                unsigned int *pWidth, unsigned int *pHeight) {
+    if (mContextLost) return false;
+    return mTextureMgr.AppendPng(buffer, size, textureGroupId, pWidth, pHeight);
+}
+
+void GCanvasWeex::RemoveTexture(int textureId) {
+    if (mContextLost) return;
+    mTextureMgr.Remove(textureId);
+}
+
+void GCanvasWeex::drawFBO(std::string fboName, GCompositeOperation compositeOp,
+                          float sx, float sy, float sw, float sh,
+                          float dx, float dy, float dw, float dh) {
+    if (!mCanvasContext->mIsFboSupported) {
+        return;
+    }
+
+    if (nullptr == mCanvasContext->mCurrentState ||
+        nullptr == mCanvasContext->mCurrentState->mShader) {
+        return;
+    }
+
+
+    mCanvasContext->Save();
+    glViewport(mCanvasContext->mX, mCanvasContext->mY, mCanvasContext->mWidth,
+               mCanvasContext->mHeight);
+
+    GFrameBufferObject &fbo = mCanvasContext->mFboMap[fboName];
+
+    mCanvasContext->UseDefaultRenderPipeline();
+
+    glDisable(GL_STENCIL_TEST);
+    glDisable(GL_DEPTH_TEST);
+
+    mCanvasContext->DoSetGlobalCompositeOperation(compositeOp, compositeOp);
+
+    GColorRGBA color = GColorWhite;
+    mCanvasContext->mCurrentState->mShader->SetOverideTextureColor(0);
+    mCanvasContext->mCurrentState->mShader->SetHasTexture(1);
+    fbo.mFboTexture.Bind();
+
+    mCanvasContext->PushRectangle(-1, -1, 2, 2, 0, 0, 1, 1, color);
+    mCanvasContext->mCurrentState->mShader->SetTransform(GTransformIdentity);
+    glDrawArrays(GL_TRIANGLES, 0, mCanvasContext->mVertexBufferIndex);
+    mCanvasContext->mVertexBufferIndex = 0;
+
+    if (mCanvasContext->HasClipRegion()) {
+        glEnable(GL_STENCIL_TEST);
+        glEnable(GL_DEPTH_TEST);
+    }
+
+    glViewport(0, 0, mCanvasContext->mWidth, mCanvasContext->mHeight);
+
+    mCanvasContext->Restore();
+}
+
+
+void GCanvasWeex::calculateFPS() {
+    ++mFrames;
+    if (mFrames >= mFps || mFrames >= 60) {
+#if defined (ANDROID) || defined (OHOS) 
+        static clock_t tvLast;
+        clock_t now = clock();
+        clock_t delta = now - tvLast;
+        if (delta >= CLOCKS_PER_SEC) {
+            double dSeconds =
+                    static_cast<double>(delta) / static_cast<double>(CLOCKS_PER_SEC);
+            mFps = static_cast<float>(static_cast<double>(mFrames) / dSeconds);
+            LOG_D("[calculateFPS] fps=%.1f", mFps);
+        } else if (delta >= 0) {
+            return; // skip if the interval is less than a second.
+        }
+
+        mFrames = 0;
+        tvLast = now;
+#endif
+
+#ifdef IOS
+        static timeval tvLast = {0, 0};
+        struct timeval tvNow;
+        gettimeofday(&tvNow, NULL);
+
+        if (tvNow.tv_sec > tvLast.tv_sec)
+        {
+            double delta = (tvNow.tv_sec - tvLast.tv_sec) +
+            (tvNow.tv_usec - tvLast.tv_usec) / 1000000;
+            mFps = static_cast<float>(static_cast<double>(mFrames) / delta);
+
+            mFrames = 0;
+            tvLast = tvNow;
+        }
+#endif
+    }
+}
+
+//for string cmd
+void GCanvasWeex::Render(const char *renderCommands, int length) {
+    if (mContextLost) {
+        return;
+    }
+    LOG_D("GCanvasWeex::Render: mContextType: %d", GetContextType());
+    if (0 != mCanvasContext->mContextType) {
+        if (length > 0) {
+            calculateFPS();
+            LOG_D("GCanvasWeex::Render:[WebGL] renderCommands:%s", renderCommands);
+            executeWebGLCommands(renderCommands, length);
+        }
+    } else {
+        if (nullptr == mCanvasContext->mCurrentState ||
+            nullptr == mCanvasContext->mCurrentState->mShader) {
+            return;
+        }
+
+        mCanvasContext->BindFBO();
+        if (length > 0) {
+            calculateFPS();
+            LOG_D("GCanvasWeex::Render:[2D] renderCommands:%s", renderCommands);
+            execute2dCommands(renderCommands, length);
+        }
+        mCanvasContext->UnbindFBO();
+        glClearColor(0, 0, 0, 0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+        LOG_D("GCanvasWeex::Render:[2D] eglGetError code:%d", eglGetError());
+        drawFBO(GCanvasContext::DefaultFboName);
+        LOG_D("GCanvasWeex::Render:[2D] eglGetError code:%d", eglGetError());
+    }
+}
+
+void GCanvasWeex::GetImageDataWithoutStringCmd(int x, int y, int w, int h, unsigned char *rgbaData) {
+    if (mContextLost ||
+        nullptr == mCanvasContext->mCurrentState ||
+        nullptr == mCanvasContext->mCurrentState->mShader
+    ) {
+        return;
+    }
+//    LOG_D("GCanvasWeex::GetImageDataWithoutStringCmd begin... xy=(%d, %d), wh=(%d, %d)", x, y, w, h);
+    mCanvasContext->BindFBO();
+    mCanvasContext->GetImageData(x, y, w, h, rgbaData);
+    mCanvasContext->UnbindFBO();
+}
+
+void GCanvasWeex::DrawImageDataWithoutStringCmd(float tw, float th, const unsigned char *rgbaData,
+                                                float sx, float sy, float sw, float sh,
+                                                float dx, float dy, float dw, float dh) {
+    if (mContextLost ||
+        nullptr == mCanvasContext->mCurrentState ||
+        nullptr == mCanvasContext->mCurrentState->mShader
+    ) {
+        return;
+    }
+//    LOG_D("GCanvasWeex::DrawImageDataWithoutStringCmd");
+    mCanvasContext->BindFBO();
+    mCanvasContext->DoDrawImageData(tw, th, rgbaData, sx, sy, sw, sh, dx, dy, dw, dh);
+    mCanvasContext->UnbindFBO();
+}
+
+//for string cmd
+void GCanvasWeex::DrawImage(int textureId, float sx, float sy, float sw, float sh,
+                            float dx, float dy, float dw, float dh) {
+    LOG_D("GCanvasWeex::DrawImage texture %d", textureId);
+    const TextureGroup *ptr_group = mTextureMgr.Get(textureId);
+    if (NULL == ptr_group) {
+        LOG_E("GCanvasWeex::DrawImage texture %d is NULL", textureId);
+        return;
+    }
+    const TextureGroup &group = *ptr_group;
+
+    if (!group.IsSplit()) {
+#ifdef IOS
+        std::map< int, int >::iterator iter = mOfflineTextures.find(textureId);
+        if (iter != mOfflineTextures.end())
+        {
+            mCanvasContext->DoScale(1, -1);
+            mOfflineTextures.erase(iter);
+        }
+#endif
+        mCanvasContext->DoDrawImage(group.mVecTexture[0]->GetWidth(),
+                                   group.mVecTexture[0]->GetHeight(),
+                                   group.mVecTexture[0]->GetGlID(), sx, sy, sw, sh, dx, dy, dw,
+                                   dh);
+    } else {
+        int start_col = sx / group.mTileWidth;
+        int stop_col =
+                (sx + sw - 1) / group.mTileWidth; // length is start with 1,so need
+        // to minus 1 before check
+        int start_row = sy / group.mTileHeight;
+        int stop_row = (sy + sh - 1) / group.mTileHeight;
+
+        int block_count = (group.mSrcWidth - 1) / group.mTileWidth +
+                          1; // spilt block per row
+
+        LOG_D("[GCanvasWeex::drawImage] row:[%d~%d], col:[%d~%d]", start_row,
+              stop_row, start_col, stop_col);
+
+        float scale_h = dh / sh;
+        float scale_w = dw / sw;
+        for (int r = start_row; r <= stop_row; ++r) {
+            int y1 = std::max(r * group.mTileHeight, static_cast<int>(sy));
+            int y2 = std::min((r + 1) * group.mTileHeight, static_cast<int>(sy + sh));
+            float new_h = (y2 - y1) * scale_h;
+
+            for (int c = start_col; c <= stop_col; ++c) {
+                int index = r * block_count + c;
+                int x1 = std::max(c * group.mTileWidth, static_cast<int>(sx));
+                int x2 = std::min((c + 1) * group.mTileWidth, static_cast<int>(sx + sw));
+                LOG_D("[GCanvasWeex::drawImage] rc:(%d, %d), x:(%d, %d), y:(%d, %d)",
+                      r, c, x1, x2, y1, y2);
+
+                mCanvasContext->DoDrawImage(group.mVecTexture[index]->GetWidth(),
+                                           group.mVecTexture[index]->GetHeight(),
+                                           group.mVecTexture[index]->GetGlID(),
+                                           x1 % group.mTileWidth, y1 % group.mTileHeight,
+                                           x2 - x1, y2 - y1, dx + (x1 - sx) * scale_w,
+                                           dy + (y1 - sy) * scale_h, (x2 - x1) * scale_w,
+                                           new_h);
+            }
+        }
+    }
+}
+
+//for string cmd
+void GCanvasWeex::UsePatternRenderPipeline(int textureListId, int textureWidth, int textureHeight,
+                                           const std::string &pattern, bool isStroke) {
+    mCanvasContext->SendVertexBufferToGPU();
+
+#ifdef IOS
+    mCanvasContext->mCurrentState->mShader = GShaderManager::getSingleton()->programForKey("PATTERN");
+#endif
+
+#ifdef ANDROID
+    mCanvasContext->mCurrentState->mShader = ((GCanvas2DContextAndroid *) mCanvasContext)->GetShaderManager()->programForKey(
+            "PATTERN");
+#endif
+
+#ifdef OHOS
+    mCanvasContext->mCurrentState->mShader = ((GCanvas2DContextHarmony *) mCanvasContext)->GetShaderManager()->programForKey(
+            "PATTERN");
+#endif    
+
+    if (nullptr == mCanvasContext->mCurrentState->mShader) {
+        return;
+    }
+    mCanvasContext->mCurrentState->mShader->Bind();
+
+    GFillStyle *style = isStroke ? mCanvasContext->mCurrentState->mStrokeStyle
+                                 : mCanvasContext->mCurrentState->mFillStyle;
+    if (style != nullptr) {
+        delete style;
+        style = nullptr;
+    }
+
+    if (textureListId >= 0 && pattern != "") {
+        style = new FillStylePattern(textureListId, pattern);
+        if (isStroke) {
+            mCanvasContext->mCurrentState->mStrokeStyle = style;
+        } else {
+            mCanvasContext->mCurrentState->mFillStyle = style;
+        }
+        mCanvasContext->mCurrentState->mShader->SetRepeatMode(
+                ((FillStylePattern *) style)->GetPattern());
+
+        mCanvasContext->mCurrentState->mFillColor = StrValueToColorRGBA("white");
+        mCanvasContext->mCurrentState->mTextureId = textureListId;
+        mCanvasContext->mCurrentState->mShader->SetTextureSize(textureWidth, textureHeight);
+    }
+}
+
+//for string cmd
+void GCanvasWeex::UsePatternRenderPipeline(int textureListId,
+                                           const std::string &pattern, bool isStroke) {
+    mCanvasContext->SendVertexBufferToGPU();
+
+#ifdef IOS
+    mCanvasContext->mCurrentState->mShader = GShaderManager::getSingleton()->programForKey("PATTERN");
+#endif
+
+#ifdef ANDROID
+    mCanvasContext->mCurrentState->mShader = ((GCanvas2DContextAndroid *) mCanvasContext)->GetShaderManager()->programForKey(
+            "PATTERN");
+#endif
+
+#ifdef OHOS
+    mCanvasContext->mCurrentState->mShader = ((GCanvas2DContextHarmony *) mCanvasContext)->GetShaderManager()->programForKey(
+            "PATTERN");
+#endif    
+    mCanvasContext->mCurrentState->mShader->Bind();
+    if (mCanvasContext->mCurrentState->mFillStyle != nullptr) {
+        delete mCanvasContext->mCurrentState->mFillStyle;
+        mCanvasContext->mCurrentState->mFillStyle = nullptr;
+    }
+    if (textureListId >= 0 && pattern != "") {
+        const Texture *texture = getTextureWithOneImage(textureListId);
+        if (texture) {
+            texture->Bind();
+            const int glId = texture->GetGlID();
+            const short tw = static_cast<short>(texture->GetWidth());
+            const short th = static_cast<short>(texture->GetHeight());
+            // 存 GL 纹理名和像素尺寸，供 fillRect → UsePatternRenderPipeline(bool) 使用
+            mCanvasContext->mCurrentState->mFillStyle =
+                    new FillStylePattern(glId, tw, th, pattern);
+            mCanvasContext->mCurrentState->mShader->SetRepeatMode(pattern);
+            mCanvasContext->mCurrentState->mShader->SetTextureSize(
+                    static_cast<float>(texture->GetWidth()),
+                    static_cast<float>(texture->GetHeight()));
+            mCanvasContext->mCurrentState->mTextureId = glId;
+            mCanvasContext->mCurrentState->mFillColor = StrValueToColorRGBA("white");
+        } else {
+            mCanvasContext->mCurrentState->mFillStyle =
+                    new FillStylePattern(textureListId, pattern);
+            mCanvasContext->mCurrentState->mShader->SetRepeatMode(pattern);
+        }
+    }
+    if (mCanvasContext->mCurrentState != nullptr) {
+        mCanvasContext->SetTransformOfShader(mCanvasContext->mCurrentState->mTransform);
+    }
+}
+
+void GCanvasWeex::parseSetTransForTextform(
+        float v1, float v2,
+        int parseMode,       // what to read: IDENTITY, FULL_XFORM, etc.
+        bool concat,         // if true, concatenate, else replace.
+        GTransform transIn, // the current xform
+        GTransform *transOut) {
+    GTransform t;
+    switch (parseMode) {
+        case SCALE:
+            t.a = v1;
+            t.d = v2;
+            break;
+        case TRANSLATE:
+            t.tx = v1;
+            t.ty = v2;
+            break;
+        default: ASSERT(0);
+            break;
+    }
+
+    if (concat) {
+        transOut->a = transIn.a * t.a + transIn.c * t.b;
+        transOut->b = transIn.b * t.a + transIn.d * t.b;
+        transOut->c = transIn.a * t.c + transIn.c * t.d;
+        transOut->d = transIn.b * t.c + transIn.d * t.d;
+        transOut->tx = transIn.a * t.tx + transIn.c * t.ty + transIn.tx;
+        transOut->ty = transIn.b * t.tx + transIn.d * t.ty + transIn.ty;
+    } else {
+        *transOut = t;
+    }
+}
+
+
+void
+GCanvasWeex::PutImageData(
+        const char *imageData,
+        int dataLength,
+        int tw,
+        int th,
+        int x,
+        int y,
+        int sx,
+        int sy,
+        int sw,
+        int sh) {
+    LOG_D("[PutImageData] xy=(%d, %d), src_wh=(%d, %d), texture_wh=(%d, %d)",
+          x, y, sw, sh, tw, tw);
+
+    std::string &pixels_data = mTempStr;
+    if ((unsigned int) dataLength > pixels_data.length())
+        pixels_data.resize(dataLength);
+
+    GLubyte *pixels = (GLubyte *) (pixels_data.c_str());
+
+    gcanvas::Base64DecodeBuf(reinterpret_cast<char *>(pixels), imageData, dataLength);
+
+    mCanvasContext->PutImageData(pixels, tw, th, x, y, sx, sy, sw, sh);
+}
+
+void
+GCanvasWeex::GetImageData(int
+                          x, int
+                          y, int
+                          w, int
+                          h, bool
+                          base64Encode,
+                          std::string &pixelsData) {
+    LOG_D("GCanvas.cpp::getImageData begin... xy=(%d, %d), wh=(%d, %d)", x,
+          y, w, h);
+
+    // use glGetPixels to get the bits from the current frame buffer
+    // Make the BYTE array, factor of 4 because it's RGBA.
+    int buf_size = 4 * w * h;
+    std::string *ptr_data = NULL;
+    if (base64Encode) {
+        ptr_data = &mTempStr;
+        if ((unsigned int) buf_size > ptr_data->length())
+            ptr_data->resize(buf_size);
+    } else {
+        ptr_data = &pixelsData;
+        ptr_data->resize(buf_size);
+    }
+
+    unsigned char *pixels = (unsigned char *) ptr_data->c_str();
+
+    mCanvasContext->GetImageData(x, y, w, h, pixels);
+
+    if (base64Encode) {
+        pixelsData.resize(gcanvas::Base64EncodeLen(buf_size));
+        gcanvas::Base64EncodeBuf((char *) (pixelsData.c_str()), ptr_data->c_str(),
+                                 buf_size);
+    }
+    LOG_D("GCanvas.cpp::getImageData end...[%d]=%s", buf_size,
+          pixelsData.c_str());
+}
+
+
+const char *GCanvasWeex::parseTokens(const char *p, float *tokens, int iMaxCount) {
+    int iToken = 0;
+
+    while (*p && *p != ';' && iToken < iMaxCount) {
+        tokens[iToken++] = fastFloat(p);
+        while (*p && (*p != ',' && *p != ';')) {
+            ++p;
+        }
+        if (*p == ',') ++p;
+    }
+    if (*p == ';') ++p;
+    return p;
+}
+
+void GCanvasWeex::parseTokesOpt(float *tokens, const char **pp) {
+    int iToken = 0;
+    const char *position[10] = {nullptr};
+    const char *p = *pp;
+    position[iToken++] = p;
+    for (; *p != ';'; p++) {
+        if (',' == *p) {
+            p++;
+            position[iToken++] = p;
+        }
+    }
+    for (int i = 0; i < iToken; i++) {
+        tokens[i] = atof(position[i]);
+    }
+    *pp = p;
+    return;
+}
+
+// From the current position, past semicolon or to end
+// set the GL matrix if we have all the right data
+
+const char *GCanvasWeex::parseSetTransformT(
+        const char *p,
+        int parseMode,       // what to read: IDENTITY, FULL_XFORM, etc.
+        bool concat,         // if true, concatenate, else replace.
+        GTransform transIn, // the current xform
+        GTransform *transOut) {
+    if (concat) {
+        GTransform t;
+        parseTokesOpt(reinterpret_cast<float *>(&t), &p);
+
+        transOut->a = transIn.a * t.a + transIn.c * t.b;
+        transOut->b = transIn.b * t.a + transIn.d * t.b;
+        transOut->c = transIn.a * t.c + transIn.c * t.d;
+        transOut->d = transIn.b * t.c + transIn.d * t.d;
+        transOut->tx = transIn.a * t.tx + transIn.c * t.ty + transIn.tx;
+        transOut->ty = transIn.b * t.tx + transIn.d * t.ty + transIn.ty;
+    } else {
+        parseTokesOpt(reinterpret_cast<float *>(transOut), &p);
+    }
+
+    if (*p == ';') ++p;
+
+    return p;
+}
+
+const char *GCanvasWeex::parseSetTransform(
+        const char *p,
+        int parseMode,       // what to read: IDENTITY, FULL_XFORM, etc.
+        bool concat,         // if true, concatenate, else replace.
+        GTransform transIn, // the current xform
+        GTransform *transOut) {
+    float tokens[6] = {0, 0, 0, 0, 0, 0};
+
+    // #define debug_Parsetokes 1
+#ifdef debug_Parsetokes
+    const char *p0 = p;
+#endif
+
+#if origin_code_realization
+    int iToken = 0;
+    while (*p && *p != ';' && iToken < 6)
+    {
+        tokens[iToken++] = atof(p);
+
+        while (*p && (*p != ',' && *p != ';'))
+        {
+            ++p;
+        }
+        if (*p == ',') ++p;
+    }
+
+#ifdef debug_Parsetokes
+
+    FILE *flog = fopen("/storage/sdcard0/ParseTokesOrigin1.txt", "a+");
+    fwrite((p0 - 1), 1, (p - p0 + 1 + 1), flog);
+    char buffer[256] = {0};
+    int len = snprintf(buffer, "\n %f,%f,%f,%f,%f,%f \n", tokens[0], tokens[1],
+                       tokens[2], tokens[3], tokens[4], tokens[5]);
+    fwrite(buffer, 1, len, flog);
+    fclose(flog);
+#endif
+#else
+    parseTokesOpt(tokens, &p);
+#endif
+
+    GTransform t;
+    switch (parseMode) {
+        case IDENTITY:
+            break;
+        case SET_XFORM:
+            t.a = tokens[0];
+            t.b = tokens[1];
+            t.c = tokens[2];
+            t.d = tokens[3];
+            t.tx = tokens[4];
+            t.ty = tokens[5];
+            break;
+        case SCALE:
+            t.a = tokens[0];
+            t.d = tokens[1];
+            break;
+        case ROTATE: {
+            double angle = tokens[0];
+
+            double ca = cos(angle);
+            double sa = sin(angle);
+
+            t.a = static_cast<float>(ca);
+            t.b = static_cast<float>(sa);
+            t.c = static_cast<float>(-sa);
+            t.d = static_cast<float>(ca);
+        }
+            break;
+        case TRANSLATE:
+            t.tx = tokens[0];
+            t.ty = tokens[1];
+            break;
+        default: ASSERT(0);
+            break;
+    }
+
+    if (concat) {
+        transOut->a = transIn.a * t.a + transIn.c * t.b;
+        transOut->b = transIn.b * t.a + transIn.d * t.b;
+        transOut->c = transIn.a * t.c + transIn.c * t.d;
+        transOut->d = transIn.b * t.c + transIn.d * t.d;
+        transOut->tx = transIn.a * t.tx + transIn.c * t.ty + transIn.tx;
+        transOut->ty = transIn.b * t.tx + transIn.d * t.ty + transIn.ty;
+    } else {
+        *transOut = t;
+    }
+
+    if (*p == ';') ++p;
+    return p;
+}
+
+const char *GCanvasWeex::parseDrawImage(const char *p, ClipStruct *clipOut) {
+#if origin_code_realization
+    float tokens[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+    int iToken = 0;
+
+    while (*p && *p != ';' && iToken < 9)
+    {
+        if (iToken == 0)
+        {
+            // First token is the texture ID
+            clipOut->textureID = FastInt(p);
+        }
+        else
+        {
+            tokens[iToken - 1] = FastFloat(p);
+        }
+        iToken++;
+        while (*p && (*p != ',' && *p != ';'))
+        {
+            ++p;
+        }
+        if (*p == ',') ++p;
+    }
+
+    clipOut->cx = tokens[0]; // cx
+    clipOut->cy = tokens[1]; // cy
+    clipOut->cw = tokens[2]; // cw
+    clipOut->ch = tokens[3]; // ch
+    clipOut->px = tokens[4]; // px
+    clipOut->py = tokens[5]; // py
+    clipOut->pw = tokens[6]; // pw
+    clipOut->ph = tokens[7]; // ph
+#else
+    clipOut->textureID = atoi(p);
+
+    for (; *p != ','; p++); // skip image.id
+    p++;
+
+    //    for (; *p != ','; p++); // skip image.src
+    //    p++;
+
+    parseTokesOpt(&clipOut->cx, &p);
+#endif
+
+    if (*p == ';') ++p;
+    return p;
+}
+
+const char *GCanvasWeex::parseName(const char *p, std::string &name) {
+    const char *old = p;
+    while (*p && *p != ';') {
+        ++p;
+    }
+    name.assign(old, p - old);
+    if (*p == ';') ++p;
+    return p;
+}
+
+const char *
+GCanvasWeex::parseBindingPara(const char *p, std::string &name, float &width, float &height) {
+    const char *old = p;
+    while (*p && *p != ',') {
+        ++p;
+    }
+    name.assign(old, p - old);
+
+    if (*p == ',') ++p;
+
+
+    width = fastFloat(p);
+    while (*p && *p != ',') {
+        ++p;
+    }
+    if (*p == ',') ++p;
+    height = fastFloat(p);
+    while (*p && *p != ';') {
+        ++p;
+    }
+    if (*p == ';') ++p;
+    return p;
+}
+
+const char *
+GCanvasWeex::parseBindingPara(const char *p, std::string &name, float &sx, float &sy, float &sw,
+                              float &sh,
+                              float &dx, float &dy, float &dw, float &dh) {
+    const char *old = p;
+    while (*p && *p != ',') {
+        ++p;
+    }
+    name.assign(old, p - old);
+
+    if (*p == ',') ++p;
+
+    float tokens[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+    parseTokesOpt(tokens, &p);
+
+    sx = tokens[0];
+    sy = tokens[1];
+    sw = tokens[2];
+    sh = tokens[3];
+
+    dx = tokens[4];
+    dy = tokens[5];
+    dw = tokens[6];
+    dh = tokens[7];
+
+    if (*p == ';') ++p;
+    return p;
+}
+
+// From the current position, past semicolon or to end
+const char *GCanvasWeex::parseUnknown(const char *p) {
+    while (*p && *p != ';') {
+        ++p;
+    }
+    if (*p == ';') ++p;
+    return p;
+}
+
+const Texture *GCanvasWeex::getTextureWithOneImage(int aId) {
+    const TextureGroup *texture_group = mTextureMgr.Get(aId);
+    if (texture_group != nullptr) {
+        return texture_group->Get(0);
+    }
+    return nullptr;
+}
+
+const char *GCanvasWeex::extractOneParameterFromCommand(char *outParameter,
+                                                        const char *commands) {
+    int i = 0;
+    const char *p = commands;
+    bool has_left_parentheses = false;
+    while (*p != ';' && (has_left_parentheses || *p != ',')) {
+        if (*p == '(') {
+            has_left_parentheses = true;
+        } else if (*p == ')') {
+            has_left_parentheses = false;
+        }
+        outParameter[i++] = *p++;
+    }
+    outParameter[i] = '\0';
+    return p;
+}
+
+
+void GCanvasWeex::execute2dCommands(const char *renderCommands, int length) {
+    if (mContextLost) return;
+
+
+    if (LOG_LEVEL_DEBUG == GetLogLevel()) {
+        char log_tmp[128];
+        snprintf(log_tmp, sizeof(log_tmp), "%s", renderCommands);
+        LOG_D("[executeRenderCommands][%d]%s", strlen(renderCommands), log_tmp);
+    }
+
+    char tmpFont[256];
+    char tmpText[1024];
+    GTransform &action = mCurrentTransform;
+
+    mCanvasContext->ClearGeometryDataBuffers();
+
+    mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d, action.tx, action.ty);
+    ClipStruct clip;
+    const char *p = renderCommands;
+    const char *end = renderCommands + length;
+    while (p < end) {
+        switch (*p) {
+            case 't': {
+                // setTransform
+                p++;
+                p = parseSetTransformT(p, SET_XFORM, false, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'd': {
+                p++;
+                // Load the clip
+                p = parseDrawImage(p, &clip);
+
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                mCanvasContext->UseDefaultRenderPipeline();
+                this->DrawImage(clip.textureID, clip.cx, clip.cy, clip.cw, clip.ch,
+                          clip.px, clip.py, clip.pw, clip.ph);
+                break;
+            }
+            case 'f': {
+                // transform
+                p++;
+                p = parseSetTransform(p, SET_XFORM, true, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'm': {
+                // resetTransform
+                p++;
+                p = parseSetTransform(p, IDENTITY, false, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'k': {
+                // scale
+                p++;
+                p = parseSetTransform(p, SCALE, true, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'r': {
+                // rotate
+                p++;
+                p = parseSetTransform(p, ROTATE, true, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'l': {
+                // translate
+                p++;
+                p = parseSetTransform(p, TRANSLATE, true, action, &action);
+                mCanvasContext->ApplyTransform(action.a, action.b, action.c, action.d,
+                                               action.tx, action.ty);
+                break;
+            }
+            case 'v': {
+                // save
+                p++;
+                mActionStack.Append(&action, 1);
+                mCanvasContext->Save();
+                if (*p == ';') {
+                    ++p;
+                }
+                break;
+            }
+            case 'e': {
+                // restore
+                p++;
+                if (mActionStack.GetSize() > 0) {
+                    mCanvasContext->Restore();
+                    action = mActionStack[mActionStack.GetSize() - 1];
+                    mActionStack.SetSize(mActionStack.GetSize() - 1);
+                }
+                if (*p == ';') {
+                    ++p;
+                }
+                break;
+            }
+            case 'a': {
+                // global alpha
+                p++;
+                float alpha = fastFloat(p);
+                mCanvasContext->SetGlobalAlpha(alpha);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'F': {
+                // fillStyle
+                p++;
+                char str[64] = "";
+                char *tmp = str;
+                while (*p && *p != ';') {
+                    *tmp = *p;
+                    ++tmp;
+                    ++p;
+                }
+                if (*p == ';') ++p;
+                GColorRGBA color = StrValueToColorRGBA(str);
+                mCanvasContext->SetFillStyle(color);
+                break;
+            }
+            case 'S': {
+                // strokeStyle
+                p++;
+                char str[64] = "";
+                char *tmp = str;
+                while (*p && *p != ';') {
+                    *tmp = *p;
+                    ++tmp;
+                    ++p;
+                }
+                if (*p == ';') ++p;
+                GColorRGBA color = StrValueToColorRGBA(str);
+                mCanvasContext->SetStrokeStyle(color);
+                break;
+            }
+            case 'K': {
+                //shadowColor
+                p++;
+                char str[64] = "";
+                char *tmp = str;
+                while (*p && *p != ';') {
+                    *tmp = *p;
+                    ++tmp;
+                    ++p;
+                }
+                if (*p == ';') ++p;
+                mCanvasContext->SetShadowColor(str);
+                break;
+            }
+            case 'Z': {
+                //shadowBlur
+                p++;
+                float blur = fastFloat(p);
+                mCanvasContext->SetShadowBlur(blur);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'X': {
+                //shadowOffsetX
+                p++;
+                float offsetX = fastFloat(p);
+                mCanvasContext->SetShadowOffsetX(offsetX);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'Y': {
+                //shadowOffsetY
+                p++;
+                float offsetY = fastFloat(p);
+                mCanvasContext->SetShadowOffsetY(offsetY);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'O': {
+                //imageSmoothingEnabled
+                p++;
+                int smooth = atoi(p);
+                mCanvasContext->SetImageSmoothingEnabled(smooth > 0);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'N': {
+                //lineDashOffset
+                p++;
+                float offset = fastFloat(p);
+                mCanvasContext->SetLineDashOffset(offset);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'I': {
+                //SetLineDash
+                p++;
+                char str[256];
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+
+                int count = atoi(str);
+                std::vector<float> params;
+                params.reserve(count);
+                for (int i = 0; i < count; ++i) {
+                    p = extractOneParameterFromCommand(str, p);
+                    p++;
+                    params.push_back(atof(str));
+                }
+                mCanvasContext->SetLineDash(params);
+                break;
+            }
+            case 'W': {
+                // lineWidth
+                p++;
+                float w = fastFloat(p);
+                mCanvasContext->SetLineWidth(w);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'C': {
+                // lineCap
+
+                p++;
+                if (strncmp(p, "butt", 4) == 0) {
+                    mCanvasContext->SetLineCap(LINE_CAP_BUTT);
+                } else if (strncmp(p, "round", 5) == 0) {
+                    mCanvasContext->SetLineCap(LINE_CAP_ROUND);
+                } else if (strncmp(p, "square", 6) == 0) {
+                    mCanvasContext->SetLineCap(LINE_CAP_SQUARE);
+                }
+
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'J': {
+                // lineJoin
+
+                p++;
+                if (strncmp(p, "miter", 4) == 0) {
+                    mCanvasContext->SetLineJoin(LINE_JOIN_MITER);
+                } else if (strncmp(p, "bevel", 5) == 0) {
+                    mCanvasContext->SetLineJoin(LINE_JOIN_BEVEL);
+                } else if (strncmp(p, "round", 5) == 0) {
+                    mCanvasContext->SetLineJoin(LINE_JOIN_ROUND);
+                }
+
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'M': {
+                // miterLimit
+                p++;
+                float w = fastFloat(p);
+                mCanvasContext->SetMiterLimit(w);
+                while (*p && *p != ';') ++p;
+                if (*p == ';') ++p;
+                break;
+            }
+            case 's': {
+                p++;
+                // strokeRect
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->StrokeRect(tokens[0], tokens[1], tokens[2], tokens[3]);
+                break;
+            }
+            case 'c': {
+                p++;
+                // clearRect
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->ClearRect(tokens[0], tokens[1], tokens[2], tokens[3]);
+                break;
+            }
+            case 'p': {
+                p++;
+                // clip
+                mCanvasContext->GCanvasContext::ClipRegion();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'q': {
+                p++;
+                // resetClip
+                mCanvasContext->ResetClip();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'o': {
+                p++;
+                // closePath
+                mCanvasContext->ClosePath();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'g': {
+                p++;
+                // moveTo
+                float tokens[2] = {0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->MoveTo(tokens[0], tokens[1]);
+                break;
+            }
+            case 'G': {
+                p++;
+                char id[128];
+                p = extractOneParameterFromCommand(id, p);
+                const int texture_id = atoi(id);
+                ++p;
+                p = extractOneParameterFromCommand(id, p);
+                const std::string repeat_mode = id;
+                ++p;
+
+                UsePatternRenderPipeline(texture_id, repeat_mode);
+                break;
+            }
+            case 'H': {
+                // createRadialGradient()
+                p++;
+                char str[128];
+                float start[3], end[3];
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                start[0] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                start[1] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                start[2] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                end[0] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                end[1] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                end[2] = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                const int stop_count = atoi(str);
+
+                if (mCanvasContext->mCurrentState->mFillStyle != nullptr) {
+                    delete mCanvasContext->mCurrentState->mFillStyle;
+                }
+                mCanvasContext->mCurrentState->mFillStyle =
+                        new FillStyleRadialGradient(start, end);
+
+                for (int i = 0; i < stop_count; ++i) {
+                    p = extractOneParameterFromCommand(str, p);
+                    p++;
+                    float pos = atof(str);
+                    p = extractOneParameterFromCommand(str, p);
+                    p++;
+                    std::string color = str;
+                    static_cast<FillStyleRadialGradient *>(
+                            mCanvasContext->mCurrentState->mFillStyle)->AddColorStop(pos, color);
+                }
+                mCanvasContext->UseRadialGradientPipeline();
+
+                break;
+            }
+            case 'D': {
+                // createLinearGradient()
+                p++;
+                char str[128];
+                GPoint start, end;
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                start.x = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                start.y = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                end.x = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                end.y = atoi(str);
+                p = extractOneParameterFromCommand(str, p);
+                p++;
+                const int stop_count = atoi(str);
+
+                if (mCanvasContext->mCurrentState->mFillStyle != nullptr) {
+                    delete mCanvasContext->mCurrentState->mFillStyle;
+                }
+                mCanvasContext->mCurrentState->mFillStyle =
+                        new FillStyleLinearGradient(start, end);
+
+                for (int i = 0; i < stop_count; ++i) {
+                    p = extractOneParameterFromCommand(str, p);
+                    p++;
+                    float pos = atof(str);
+                    p = extractOneParameterFromCommand(str, p);
+                    p++;
+                    std::string color = str;
+                    static_cast<FillStyleLinearGradient *>(
+                            mCanvasContext->mCurrentState->mFillStyle)->AddColorStop(pos, color);
+                }
+                mCanvasContext->UseLinearGradientPipeline();
+
+                break;
+            }
+            case 'i': {
+                p++;
+                // lineTo
+                float tokens[2] = {0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->LineTo(tokens[0], tokens[1]);
+                break;
+            }
+            case 'u': {
+                p++;
+                // quadraticCurveTo
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->QuadraticCurveTo(tokens[0], tokens[1], tokens[2], tokens[3]);
+                break;
+            }
+            case 'z': {
+                p++;
+                // bezierCurveTo
+                float tokens[6] = {0, 0, 0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->BezierCurveTo(tokens[0], tokens[1], tokens[2], tokens[3],
+                                              tokens[4], tokens[5]);
+                break;
+            }
+            case 'h': {
+                p++;
+                // arcTo
+                float tokens[6] = {0, 0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->ArcTo(tokens[0], tokens[1], tokens[2], tokens[3], tokens[4]);
+                break;
+            }
+            case 'b': {
+                p++;
+                mCanvasContext->BeginPath();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'n': {
+                p++;
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->FillRect(tokens[0], tokens[1], tokens[2], tokens[3]);
+                break;
+            }
+            case 'w': {
+                p++;
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->Rect(tokens[0], tokens[1], tokens[2], tokens[3]);
+                break;
+            }
+            case 'L': {
+                p++;
+                mCanvasContext->Fill();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'x': {
+                p++;
+                mCanvasContext->Stroke();
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'y': {
+                p++;
+                float tokens[6] = {0, 0, 0, 0, 0, 0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->Arc(tokens[0], tokens[1], tokens[2], tokens[3], tokens[4],
+                                    tokens[5]);
+                break;
+            }
+            case 'B': {
+                p++;
+                float tokens[1] = {0};
+                p = parseTokens(p, tokens);
+
+                mCanvasContext->DoSetGlobalCompositeOperation(GCompositeOperation(tokens[0]));
+                break;
+            }
+            case 'A': {
+                p++;
+                float tokens[1] = {0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->mCurrentState->mTextAlign = GTextAlign(tokens[0]);
+                break;
+            }
+            case 'E': {
+                p++;
+                float tokens[1] = {0};
+                p = parseTokens(p, tokens);
+                mCanvasContext->mCurrentState->mTextBaseline = GTextBaseline(tokens[0]);
+                break;
+            }
+            case 'T': { // fillText
+                p++;
+
+                int textLen = 0;
+                float tokens[3] = {0, 0, 0};
+                const char *pStart = p;
+                while (*p && (*p != ',' && *p != ';')) {
+                    textLen++;
+                    ++p;
+                }
+                p++;
+                p = parseTokens(p, tokens);
+                if (textLen > 0) {
+                    strncpy(tmpText, pStart, textLen);
+                    tmpText[textLen] = 0;
+                    float maxWidth = tokens[2];
+                    if (maxWidth < 0.0001) {
+                        maxWidth = SHRT_MAX;
+                    }
+                    mCanvasContext->DrawText(tmpText, tokens[0], tokens[1], maxWidth);
+                }
+
+                break;
+            }
+            case 'U': { // strokeText
+                p++;
+
+                int textLen = 0;
+                float tokens[3] = {0, 0, 0};
+                const char *pStart = p;
+                while (*p && (*p != ',' && *p != ';')) {
+                    textLen++;
+                    ++p;
+                }
+                p++;
+                p = parseTokens(p, tokens);
+                if (textLen > 0) {
+                    strncpy(tmpText, pStart, textLen);
+                    tmpText[textLen] = 0;
+                    float maxWidth = tokens[2];
+                    if (maxWidth < 0.0001) {
+                        maxWidth = SHRT_MAX;
+                    }
+                    mCanvasContext->StrokeText(tmpText, tokens[0], tokens[1], maxWidth);
+                }
+
+                break;
+            }
+            case 'V': { // measureText
+                p++;
+
+                int textLen = 0;
+                const char *pStart = p;
+                while (*p && *p != ';') {
+                    textLen++;
+                    ++p;
+                }
+
+                float width = 7.0;
+                float height = 1.5;
+                float actualBoundingBoxAscent = 1.15;
+                float actualBoundingBoxDescent = 0.35;
+                if (textLen > 0) {
+                    strncpy(tmpText, pStart, textLen);
+                    tmpText[textLen] = 0;
+                    float *tmpMeasure = mCanvasContext->MeasureText(tmpText);
+                    width = tmpMeasure[0];
+                    height = tmpMeasure[1];
+                    actualBoundingBoxAscent = tmpMeasure[2];
+                    actualBoundingBoxDescent = tmpMeasure[3];
+                    delete tmpMeasure;
+                }
+                std::string jsonResult = "{\"width\":";
+                jsonResult += std::to_string(width);
+                jsonResult += ",\"height\":";
+                jsonResult += std::to_string(height);
+                jsonResult += ",\"actualBoundingBoxAscent\":";
+                jsonResult += std::to_string(actualBoundingBoxAscent);
+                jsonResult += ",\"actualBoundingBoxDescent\":";
+                jsonResult += std::to_string(actualBoundingBoxDescent);
+                jsonResult += "}";
+                setSyncResult(jsonResult);
+
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'j': {
+                p++;
+                int textLen = 0;
+                const char *pStart = p;
+                while (*p && (*p != ',' && *p != ';')) {
+                    textLen++;
+                    ++p;
+                }
+                if (textLen > 0) {
+                    strncpy(tmpFont, pStart, textLen);
+                    tmpFont[textLen] = 0;
+                    mCanvasContext->SetFont(tmpFont);
+                }
+                if (*p == ';') ++p;
+
+                break;
+            }
+            case 'P': // PutImageData
+            {
+                p++;
+                const char *begin_pos = p;
+
+                while (*p && *p != ',') {
+                    ++p;
+                }
+                int data_len = static_cast<int>(p - begin_pos);
+                LOG_D("[executeRenderCommands] data_len:%d", data_len);
+
+                p++;
+                float tokens[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+                p = parseTokens(p, tokens, 8);
+
+                PutImageData(begin_pos, data_len, tokens[0], tokens[1],
+                             tokens[2], tokens[3], tokens[4], tokens[5],
+                             tokens[6], tokens[7]);
+
+                if (*p == ';') ++p;
+                break;
+            }
+            case 'R': {
+                p++;
+                float tokens[4] = {0, 0, 0, 0};
+                p = parseTokens(p, tokens, 4);
+                std::string imageDataResult;
+                GetImageData(tokens[0], tokens[1], tokens[2], tokens[3], true, imageDataResult);
+                setSyncResult(imageDataResult);
+                break;
+            }
+            default: {
+                LOG_W("unknown error");
+                LOG_W("command: %s", p);
+                p = parseUnknown(p);
+            }
+        }
+    }
+#ifndef OHOS
+    if (LOG_LEVEL_DEBUG == GetLogLevel()) {
+        mCanvasContext->Save();
+        mCanvasContext->SetFillStyle(StrValueToColorRGBA("black"));
+#if defined (ANDROID)
+        if (mCanvasContext->mCurrentState->mFont != nullptr) {
+            delete mCanvasContext->mCurrentState->mFont;
+        }
+        mCanvasContext->mCurrentState->mFont = new GFontStyle("20px");
+#endif
+        char fpsString[20];
+        snprintf(fpsString, sizeof(fpsString), "%.0f", mFps);
+        mCanvasContext->DrawText(fpsString, 10, 25, 100);
+        mCanvasContext->Restore();
+
+    }
+#endif
+    mCanvasContext->SendVertexBufferToGPU();
+}
+
+void GCanvasWeex::setSyncResult(std::string result) {
+    mResult = result;
+}
+
+#if defined (ANDROID) || defined (OHOS) 
+
+std::string GCanvasWeex::exeSyncCmd(int type, const char *&args) {
+
+    if (mContextLost) {
+        return "";
+    }
+
+    LOG_D("[GCanvasWeex::exeSyncCmd] type=%d,context type=%d,TODATAURL=%d,width=%d,height=%d,args=%s\n",
+          type, GetContextType(), TODATAURL, mCanvasContext->mWidth, mCanvasContext->mHeight, args);
+
+
+    if (0 == GetContextType()) {
+    }
+
+
+    return "";
+}
+
+int GCanvasWeex::getCmdType(int type) {
+    return type >> 30;
+}
+
+int GCanvasWeex::getSyncAttrib(int type) {
+    return (type >> 29) & 0x1;
+}
+
+int GCanvasWeex::getOpType(int type) {
+    return type & 0x1fff;
+}
+
+void GCanvasWeex::signalUpGLthread() {
+    return;
+}
+
+
+std::string GCanvasWeex::canvasProc(int op, int sync, std::string args) {
+
+    LOG_D("canvasProc start.");
+
+    if (args.c_str() == nullptr || args.length() == 0 ||
+        !strcmp(args.c_str(), "")) {
+        return "";
+    }
+
+    LOG_D("canvasProc,length = %d,args = %s\n", args.length(), args.c_str());
+    this->Render(args.c_str(), (int) args.length());
+    LOG_D("canvasProc finished.");
+
+    return "";
+}
+
+std::string GCanvasWeex::webglProc(int op, int sync, std::string args) {
+    LOG_D("webglProc start.%s",args.c_str());
+    if (args.c_str() == nullptr || args.length() == 0 ||
+        !strcmp(args.c_str(), "")) {
+        return "";
+    }
+    const char *commands = args.c_str();
+    executeWebGLCommands(commands, (int) args.length());
+    LOG_D("webglProc finished.");
+    return "";
+}
+
+std::string GCanvasWeex::vulkanProc(int op, int sync, std::string args) {
+    switch (op) {
+
+    }
+
+    return "";
+}
+
+std::string GCanvasWeex::metalProc(int op, int sync, std::string args) {
+    switch (op) {
+
+    }
+
+    return "";
+}
+
+const char *GCanvasWeex::CallNative(int type, const std::string &args) {
+    if (mContextLost) {
+        LOG_E("context lost, return");
+        return "";
+    }
+
+    if (mExit) {
+        LOG_E("request exit, return");
+        return "";
+    }
+
+    int sync = getSyncAttrib(type);
+
+    struct GCanvasCmd *p = new struct GCanvasCmd();
+    p->type = type;
+    // `= args.c_str()` is deep copy but `= args` not, we need deep copy, otherwise if not sync,
+    // sometimes `args` is freed by je->ReleaseStringUTFChars(renderCommands, rc) in Java_com_taobao_gcanvas_GCanvasJNI_render
+    // thus `delete p` in GCanvasWeex::QueueProc will cause APP crash `A/libc(6413): Fatal signal 6 (SIGABRT), code -1 (SI_QUEUE) in tid 6684 (JNISurfaceTextu)`
+    p->args = args.c_str();
+
+    if (sync == SYNC) {
+        // TODO: remove this mCmdQueue.empty line if webgl also don't need this since the job is done by mCallNative
+        // while (!mCmdQueue.empty()) {}
+
+        // because bindImageTexture is async with mBitmapQueue and don't know why texture will display
+        // black if just replace mProxy->addBitmapQueue(p) by mProxy->bindTexture(*p) directly in
+        // core/android/3d/view/grenderer.cpp, so to getImageData just after CanvasRenderingContext2D.drawImage()
+        // need below to let flushJsCommands2CallNative('sync') wait GCanvasWeex::bindTexture() done
+        while (!mBitmapQueue.empty()) {}
+
+        sem_wait(&mCallNative);
+    }
+
+    mCmdQueue.push(p);
+
+    signalUpGLthread();
+
+    LOG_D("CallNative sync:%d",sync);
+    if (sync == SYNC) {
+        LOG_D("call native sync call, start wait. cmd is %s", args.c_str());
+        gcanvas::waitUtilTimeout(&mSyncSem, GCANVAS_TIMEOUT);
+        LOG_D("call native sync result: %s", mResult.c_str());
+        if (mResult.length() > 0) {
+            char *resultChar = new char[mResult.length() + 1];
+            strcpy(resultChar, mResult.c_str());
+            setSyncResult("");
+            sem_post(&mCallNative);
+            return resultChar;
+        } else {
+            LOG_D("return empty string");
+            sem_post(&mCallNative);
+            return "";
+        }
+    }
+
+    return nullptr;
+}
+
+void GCanvasWeex::clearCmdQueue() {
+
+    GCanvasManager *theManager = GCanvasManager::GetManager();
+    theManager->clearQueueByContextId(mContextId);
+    while (!mCmdQueue.empty()) {
+        struct GCanvasCmd *p;
+        if (mCmdQueue.try_pop(p)) {
+            delete p;
+        } else {
+            break;
+        }
+    }
+
+    while (!mBitmapQueue.empty()) {
+        struct BitmapCmd *p;
+        if (mBitmapQueue.try_pop(p)) {
+            if (p != nullptr && p->Bitmap != nullptr) {
+                free(p->Bitmap);
+                p->Bitmap = nullptr;
+            }
+            delete p;
+        } else {
+            break;
+        }
+    }
+
+}
+
+void GCanvasWeex::QueueProc(ConcurrenceQueue<struct GCanvasCmd *> *queue) {
+    if (queue == nullptr) {
+        return;
+    }
+    struct GCanvasCmd *p;
+    if (queue->try_pop(p)) {
+        int type = p->type;
+        int cmd = getCmdType(type);
+        int op = getOpType(type);
+        int sync = getSyncAttrib(type);
+
+        LOG_D("start to process queue cmd.");
+
+        switch (cmd) {
+            case CANVAS: {
+                canvasProc(op, sync, p->args);
+                break;
+            }
+            case WEBGL: {
+                webglProc(op, sync, p->args);
+                break;
+            }
+            case VULKAN: {
+                vulkanProc(op, sync, p->args);
+                break;
+            }
+            case METAL: {
+                metalProc(op, sync, p->args);
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+
+        if (op == 1) {
+            setRefreshFlag(true);
+        }
+
+        if (sync == SYNC) {
+            setSyncFlag();
+        }
+
+        delete p;
+    }
+}
+
+void GCanvasWeex::LinkNativeGLProc() {
+    if (mContextLost) {
+        LOG_E("in LinkNativeGLProc mContextLost");
+        clearCmdQueue();
+        return;
+    }
+
+    // For now getQueueByContextId() is meaningless cause no code use AddtoQueue() ,
+    // and if someday use it, need refactor queue from std::queue to ConcurrenceQueue
+    // just as what mCmdQueue did
+    // GCanvasManager *theManager = GCanvasManager::GetManager();
+    // std::queue<struct GCanvasCmd *> *queue = theManager->getQueueByContextId(
+    //         mContextId);
+    // if (queue != nullptr) {
+    //     LOG_E("in LinkNativeProc QueueProc queue");
+    //     QueueProc(queue);
+    // }
+    //    LOG_D("in LinkNativeProc QueueProc mCmdQueue");
+    QueueProc(&mCmdQueue);
+
+    // if (queue != nullptr) {
+    //     delete queue;
+    // }
+}
+
+void GCanvasWeex::setSyncFlag() {
+    mSync = true;
+}
+
+void GCanvasWeex::setThreadExit() {
+    mExit = true;
+}
+
+void GCanvasWeex::setContextLost(bool lost) {
+    mContextLost = lost;
+}
+
+void GCanvasWeex::finishProc() {
+    if (mSync == SYNC) {
+        LOG_D("LinkNativeGLProc,sync proc result=%s\n", mResult.c_str());
+        sem_post(&mSyncSem);
+        mSync = false;
+    }
+}
+
+void GCanvasWeex::setRefreshFlag(bool refresh) {
+
+}
+
+
+void GCanvasWeex::addBitmapQueue(struct BitmapCmd *p) {
+    mBitmapQueue.push(p);
+}
+
+void GCanvasWeex::processAllBitmapQueue() {
+    while (!mBitmapQueue.empty()) {
+        struct BitmapCmd *p;
+        if (mBitmapQueue.try_pop(p)) {
+            if (p->id == -1) {
+                DrawImageDataWithoutStringCmd(p->tw,
+                                              p->th,
+                                              (unsigned char *)(p->Bitmap),
+                                              p->sx,
+                                              p->sy,
+                                              p->sw,
+                                              p->sh,
+                                              p->dx,
+                                              p->dy,
+                                              p->dw,
+                                              p->dh);
+                free(p->Bitmap);
+            } else {
+                bindTexture(*p);
+                free(p->Bitmap);
+                p->Bitmap = nullptr;
+            }
+
+            delete p;
+        } else {
+            break;
+        }
+    }
+}
+
+void GCanvasWeex::bindTexture(struct BitmapCmd cmd) {
+    GLuint glID;
+    LOG_D("DO BIND TEXTURE. context type = %d", GetContextType());
+
+    // 同一 imageId 再次 bind 时复用已有 GL 纹理。
+    // TextureMgr::Append 会 Clear() 删掉旧纹理，createPattern / fillRect
+    // 仍握着旧 glId，表现为先全红（采样到单像素）再全黑（纹理已删）。
+    const Texture *existing = getTextureWithOneImage(cmd.id);
+    if (existing != nullptr && existing->GetWidth() == cmd.width &&
+        existing->GetHeight() == cmd.height) {
+        return;
+    }
+
+    //step 1:bindtexture
+    glGenTextures(1, &glID);
+    glBindTexture(GL_TEXTURE_2D, glID);
+    if (mCanvasContext->ImageSmoothingEnabled()) {
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                        GL_LINEAR_MIPMAP_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                        GL_LINEAR);
+    } else {
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                        GL_NEAREST);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                        GL_NEAREST);
+    }
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
+                    GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
+                    GL_CLAMP_TO_EDGE);
+
+    glTexImage2D(cmd.target, cmd.level, cmd.interformat, cmd.width,
+                 cmd.height, 0, cmd.format,
+                 cmd.type, cmd.Bitmap);
+
+    //step 2:save textureid
+    glGenerateMipmap(GL_TEXTURE_2D);
+    AddTexture(cmd.id, glID, cmd.width, cmd.height);
+}
+
+void GCanvasWeex::bindTexture(GTexture *texture) {
+
+
+    if (GetContextType() == 0) {
+        texture->Bind();
+        //        AddTexture(texture->GetTextureID(), texture->GetTextureID(), texture->GetWidth(), texture->GetHeight());
+
+    }
+
+
+}
+
+bool GCanvasWeex::continueProcess() {
+
+    if (mContextLost) {
+        return false;
+    }
+
+    return !mBitmapQueue.empty() || !mCmdQueue.empty();
+
+}
+
+Callback::Callback(const char *id, const char *res,
+                   bool error) {
+    strncpy(callbackId, id, ALLOCATED - 1);
+    callbackId[ALLOCATED - 1] = 0;
+
+    strncpy(result, res, ALLOCATED - 1);
+    result[ALLOCATED - 1] = 0;
+    isError = error;
+}
+
+
+// Get the front of the callback queue
+Callback *GCanvasWeex::GetNextCallback() {
+    if (!mCallbacks.IsEmpty())
+        return mCallbacks[0];
+    else
+        return nullptr;
+}
+
+// delete the front of the callback queue
+void GCanvasWeex::PopCallbacks() {
+    if (!mCallbacks.IsEmpty()) mCallbacks.RemoveAt(0);
+}
+
+
+// push to the end of the callback queue
+void GCanvasWeex::AddCallback(const char *callbackID, const char *result,
+                              bool isError) {
+    if (callbackID != nullptr && *callbackID != '\0') {
+        Callback *cb = new Callback(callbackID, result, isError);
+        mCallbacks.Append(&cb, 1);
+        LOG_D("Canvas::AddCallback - Callback created: %s, %s, %d",
+              callbackID, result, isError);
+    }
+}
+
+#endif
+
+} //namespace gcanvas
+
+#endif