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

package/harmony/gcanvas/src/main/cpp/GCanvasEngine.cpp

@@ -0,0 +1,665 @@
+#include "GCanvasEngine.h"
+
+#include "core/src/RNCGCanvasBridge.h"
+#include "core/src/support/Encode.h"
+#include "core/src/support/Log.h"
+
+#include <ace/xcomponent/native_interface_xcomponent.h>
+#include <hilog/log.h>
+#include <multimedia/image_framework/image/image_common.h>
+#include <multimedia/image_framework/image/image_packer_native.h>
+#include <multimedia/image_framework/image/pixelmap_native.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <dirent.h>
+#include <limits>
+#include <set>
+#include <sstream>
+#include <sys/stat.h>
+#include <utility>
+
+#define GC_LOGE(...) OH_LOG_ERROR(LOG_APP, __VA_ARGS__)
+
+namespace {
+
+constexpr int32_t WEBGL_ASYNC_TYPE = 0x60000000;
+constexpr int32_t TWO_D_SYNC_TYPE = 0x20000000;
+constexpr const char *SYSTEM_FONT_LOCATION = "/system/fonts/";
+
+bool FileExists(const std::string &path) {
+    struct stat fileStat {};
+    return stat(path.c_str(), &fileStat) == 0 && S_ISREG(fileStat.st_mode);
+}
+
+std::string ToLower(std::string value) {
+    std::transform(value.begin(), value.end(), value.begin(), [](unsigned char ch) {
+        return static_cast<char>(std::tolower(ch));
+    });
+    return value;
+}
+
+bool IsFontFile(const std::string &fileName) {
+    const std::string lower = ToLower(fileName);
+    return lower.size() > 4 &&
+        (lower.rfind(".ttf") == lower.size() - 4 ||
+         lower.rfind(".otf") == lower.size() - 4 ||
+         lower.rfind(".ttc") == lower.size() - 4);
+}
+
+std::string RemoveExtension(const std::string &fileName) {
+    const size_t pos = fileName.find_last_of('.');
+    return pos == std::string::npos ? fileName : fileName.substr(0, pos);
+}
+
+void InsertFontWithAliases(const std::string &fontName, const std::string &fontFile) {
+    if (fontName.empty() || fontFile.empty()) {
+        return;
+    }
+    std::set<std::string> aliases;
+    aliases.insert(fontName);
+    aliases.insert(ToLower(fontName));
+    std::string spaced = fontName;
+    std::replace(spaced.begin(), spaced.end(), '_', ' ');
+    std::replace(spaced.begin(), spaced.end(), '-', ' ');
+    aliases.insert(spaced);
+    aliases.insert(ToLower(spaced));
+    for (const auto &alias : aliases) {
+        if (!alias.empty() && !rnoh::glHasFontFamily(alias)) {
+            rnoh::glInsertFontFamily(alias, fontFile);
+        }
+    }
+}
+
+void InitializeSystemFonts() {
+    static std::once_flag once;
+    std::call_once(once, [] {
+        rnoh::glSetSystemFontLocation(SYSTEM_FONT_LOCATION);
+        const std::string defaultFont = "HarmonyOS_Sans.ttf";
+        if (FileExists(std::string(SYSTEM_FONT_LOCATION) + defaultFont)) {
+            rnoh::glSetDefaultFontFile(defaultFont);
+            InsertFontWithAliases("sans-serif", defaultFont);
+            InsertFontWithAliases("sans", defaultFont);
+            InsertFontWithAliases("default", defaultFont);
+        }
+
+        DIR *dir = opendir(SYSTEM_FONT_LOCATION);
+        if (dir == nullptr) {
+            GC_LOGE("Cannot open HarmonyOS system font directory");
+            return;
+        }
+        dirent *entry = nullptr;
+        while ((entry = readdir(dir)) != nullptr) {
+            const std::string fileName(entry->d_name);
+            if (IsFontFile(fileName)) {
+                InsertFontWithAliases(RemoveExtension(fileName), fileName);
+            }
+        }
+        closedir(dir);
+    });
+}
+
+} // namespace
+
+namespace gcanvas {
+
+GCanvasEngine &GCanvasEngine::Instance() {
+    static GCanvasEngine instance;
+    return instance;
+}
+
+GCanvasEngine::GCanvasEngine() {
+    InitializeSystemFonts();
+}
+
+bool GCanvasEngine::IsValidImage(const void *pixels, int32_t width, int32_t height, size_t &byteLength) {
+    byteLength = 0;
+    if (pixels == nullptr || width <= 0 || height <= 0) {
+        return false;
+    }
+    const size_t w = static_cast<size_t>(width);
+    const size_t h = static_cast<size_t>(height);
+    if (w > std::numeric_limits<size_t>::max() / h || w * h > std::numeric_limits<size_t>::max() / 4U) {
+        return false;
+    }
+    byteLength = w * h * 4U;
+    return true;
+}
+
+void GCanvasEngine::OnSurfaceCreated(const std::string &componentId, void *window,
+                                     uint64_t width, uint64_t height) {
+    if (componentId.empty() || window == nullptr || width == 0 || height == 0) {
+        GC_LOGE("OnSurfaceCreated received invalid surface");
+        return;
+    }
+
+    CanvasSurface snapshot;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[componentId];
+        surface.componentId = componentId;
+        surface.window = window;
+        surface.width = width;
+        surface.height = height;
+        snapshot = surface;
+    }
+
+    // Create the core canvas before starting its viewport. Otherwise the first
+    // renderer loop can observe a null proxy while initializing the surface.
+    {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasSetContextType(componentId, snapshot.contextType);
+        rnoh::gCanvasSetEnableFboMsaa(componentId, snapshot.enableFboMsaa);
+        rnoh::gCanvasSetDevicePixelRatio(componentId, snapshot.devicePixelRatio);
+        rnoh::gCanvasSurfaceCreated(componentId, static_cast<OHNativeWindow *>(window), width, height, "");
+    }
+
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        ready = rnoh::gCanvasIsReady(componentId);
+    }
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(componentId);
+        if (it != surfaces_.end()) {
+            it->second.isReady = ready;
+        }
+    }
+    if (ready) {
+        FlushPending(componentId);
+    }
+}
+
+void GCanvasEngine::OnSurfaceChanged(const std::string &componentId, void *window,
+                                     uint64_t width, uint64_t height) {
+    if (componentId.empty() || width == 0 || height == 0) {
+        return;
+    }
+    void *nativeWindow = window;
+    CanvasSurface snapshot;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[componentId];
+        surface.componentId = componentId;
+        if (nativeWindow != nullptr) {
+            surface.window = nativeWindow;
+        } else {
+            nativeWindow = surface.window;
+        }
+        surface.width = width;
+        surface.height = height;
+        snapshot = surface;
+    }
+    if (nativeWindow == nullptr) {
+        return;
+    }
+    {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasSetEnableFboMsaa(componentId, snapshot.enableFboMsaa);
+        rnoh::gCanvasSetDevicePixelRatio(componentId, snapshot.devicePixelRatio);
+        rnoh::gCanvasSetContextType(componentId, snapshot.contextType);
+        rnoh::gCanvasSurfaceCreated(componentId, static_cast<OHNativeWindow *>(nativeWindow), width, height, "");
+    }
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        ready = rnoh::gCanvasIsReady(componentId);
+    }
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        surfaces_[componentId].isReady = ready;
+    }
+    if (ready) {
+        FlushPending(componentId);
+    }
+}
+
+void GCanvasEngine::OnSurfaceDestroyed(const std::string &componentId) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(componentId);
+        if (it != surfaces_.end()) {
+            it->second.isReady = false;
+            it->second.window = nullptr;
+        }
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::gCanvasDestroy(componentId);
+}
+
+void GCanvasEngine::Enable(const std::string &componentId, const std::vector<double> &config) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    CanvasSurface &surface = surfaces_[componentId];
+    surface.componentId = componentId;
+    surface.enabled = true;
+    // Android treats config as renderer options. Width and height are sourced
+    // only from XComponent callbacks, never from this configuration array.
+    (void)config;
+}
+
+void GCanvasEngine::Disable(const std::string &refId) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        surfaces_.erase(refId);
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::gCanvasDestroy(refId);
+}
+
+void GCanvasEngine::ConfigureView(const std::string &refId, bool enableFboMsaa) {
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[refId];
+        surface.componentId = refId;
+        surface.enableFboMsaa = enableFboMsaa;
+        ready = surface.isReady;
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasSetEnableFboMsaa(refId, enableFboMsaa);
+    }
+}
+
+void GCanvasEngine::Render(const std::string &canvasId, const std::string &cmd, int32_t type) {
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[canvasId];
+        surface.componentId = canvasId;
+        ready = surface.isReady;
+        if (!ready) {
+            surface.pendingRenders.push_back({cmd, type});
+        }
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        (void)rnoh::gCanvasRender(canvasId, cmd, type);
+    }
+}
+
+std::string GCanvasEngine::ExtendCallNative(const std::string &contextId,
+                                            const std::string &args, int32_t type) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(contextId);
+        if (it == surfaces_.end() || !it->second.isReady) {
+            return "";
+        }
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    return rnoh::gCanvasRender(contextId, args, type);
+}
+
+void GCanvasEngine::SetContextType(int32_t contextType, const std::string &refId) {
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[refId];
+        surface.componentId = refId;
+        surface.contextType = contextType;
+        surface.contextTypeSet = true;
+        ready = surface.isReady;
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasSetContextType(refId, contextType);
+    }
+}
+
+void GCanvasEngine::SetDevicePixelRatio(const std::string &refId, double ratio) {
+    if (!std::isfinite(ratio) || ratio <= 0) {
+        ratio = 1.0;
+    }
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[refId];
+        surface.componentId = refId;
+        surface.devicePixelRatio = ratio;
+        ready = surface.isReady;
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasSetDevicePixelRatio(refId, ratio);
+    }
+}
+
+void GCanvasEngine::ResetGlViewport(const std::string &refId) {
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::gCanvasResetGlViewport(refId);
+}
+
+std::string GCanvasEngine::EncodePixelMapDataUrl(const std::vector<uint8_t> &rgba, uint32_t width,
+                                                 uint32_t height, const std::string &requestedMime,
+                                                 double quality) {
+    if (rgba.empty() || width == 0 || height == 0) {
+        return "";
+    }
+    const std::string mimeType = requestedMime == "image/jpeg" ? "image/jpeg" : "image/png";
+
+    OH_Pixelmap_InitializationOptions *pixelOptions = nullptr;
+    OH_PixelmapNative *pixelMap = nullptr;
+    OH_ImagePackerNative *packer = nullptr;
+    OH_PackingOptions *packingOptions = nullptr;
+    std::string result;
+
+    Image_ErrorCode error = OH_PixelmapInitializationOptions_Create(&pixelOptions);
+    if (error != IMAGE_SUCCESS || pixelOptions == nullptr) {
+        return "";
+    }
+    OH_PixelmapInitializationOptions_SetWidth(pixelOptions, width);
+    OH_PixelmapInitializationOptions_SetHeight(pixelOptions, height);
+    OH_PixelmapInitializationOptions_SetPixelFormat(pixelOptions, PIXEL_FORMAT_RGBA_8888);
+    OH_PixelmapInitializationOptions_SetSrcPixelFormat(pixelOptions, PIXEL_FORMAT_RGBA_8888);
+    OH_PixelmapInitializationOptions_SetAlphaType(pixelOptions, PIXELMAP_ALPHA_TYPE_UNPREMULTIPLIED);
+    error = OH_PixelmapNative_CreatePixelmap(const_cast<uint8_t *>(rgba.data()), rgba.size(), pixelOptions, &pixelMap);
+    OH_PixelmapInitializationOptions_Release(pixelOptions);
+    if (error != IMAGE_SUCCESS || pixelMap == nullptr) {
+        return "";
+    }
+
+    error = OH_ImagePackerNative_Create(&packer);
+    if (error == IMAGE_SUCCESS && packer != nullptr) {
+        error = OH_PackingOptions_Create(&packingOptions);
+    }
+    if (error == IMAGE_SUCCESS && packingOptions != nullptr) {
+        Image_String mime = {const_cast<char *>(mimeType.data()), mimeType.size()};
+        error = OH_PackingOptions_SetMimeType(packingOptions, &mime);
+        const uint32_t normalizedQuality = static_cast<uint32_t>(
+            std::round(std::clamp(quality, 0.0, 1.0) * 100.0));
+        if (error == IMAGE_SUCCESS) {
+            error = OH_PackingOptions_SetQuality(packingOptions, normalizedQuality);
+        }
+
+        const size_t rawSize = rgba.size();
+        if (rawSize <= (std::numeric_limits<size_t>::max() - 65536U) / 2U) {
+            size_t outputSize = std::max<size_t>(rawSize * 2U + 65536U, 1024U * 1024U);
+            std::vector<uint8_t> encoded(outputSize);
+            if (error == IMAGE_SUCCESS) {
+                error = OH_ImagePackerNative_PackToDataFromPixelmap(
+                    packer, packingOptions, pixelMap, encoded.data(), &outputSize);
+            }
+            if (error == IMAGE_SUCCESS && outputSize <= encoded.size() &&
+                outputSize <= static_cast<size_t>(std::numeric_limits<int>::max())) {
+                int encodedLength = static_cast<int>(outputSize);
+                std::string base64(static_cast<size_t>(Base64EncodeLen(encodedLength)), '\0');
+                Base64EncodeBuf(base64.data(), reinterpret_cast<const char *>(encoded.data()), encodedLength);
+                base64.resize(static_cast<size_t>(encodedLength));
+                result = "data:" + mimeType + ";base64," + base64;
+            }
+        }
+    }
+
+    if (packingOptions != nullptr) {
+        OH_PackingOptions_Release(packingOptions);
+    }
+    if (packer != nullptr) {
+        OH_ImagePackerNative_Release(packer);
+    }
+    OH_PixelmapNative_Release(pixelMap);
+    return result;
+}
+
+std::string GCanvasEngine::ToDataURL(const std::string &refId, const std::string &mimeType,
+                                     double quality) {
+    uint64_t width = 0;
+    uint64_t height = 0;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(refId);
+        if (it == surfaces_.end() || !it->second.isReady) {
+            return "";
+        }
+        width = it->second.width;
+        height = it->second.height;
+    }
+    if (width == 0 || height == 0 || width > static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) ||
+        height > static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) ||
+        width > std::numeric_limits<size_t>::max() / height ||
+        width * height > std::numeric_limits<size_t>::max() / 4U) {
+        return "";
+    }
+
+    std::ostringstream command;
+    command << "R0,0," << width << ',' << height << ';';
+    std::string rawBase64;
+    {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rawBase64 = rnoh::gCanvasRender(refId, command.str(), TWO_D_SYNC_TYPE);
+    }
+    if (rawBase64.empty() || rawBase64.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+        return "";
+    }
+
+    std::vector<uint8_t> rgba(static_cast<size_t>(width * height * 4U));
+    int encodedLength = static_cast<int>(rawBase64.size());
+    const int decodedLength = Base64DecodeBuf(reinterpret_cast<char *>(rgba.data()), rawBase64.data(), encodedLength);
+    if (decodedLength < 0 || static_cast<size_t>(decodedLength) != rgba.size()) {
+        GC_LOGE("toDataURL readback size mismatch");
+        return "";
+    }
+    return EncodePixelMapDataUrl(rgba, static_cast<uint32_t>(width), static_cast<uint32_t>(height),
+                                 mimeType, quality);
+}
+
+void GCanvasEngine::DrawCanvas2Canvas(const DrawCanvas2CanvasArgs &args) {
+    if (args.srcComponentId.empty() || args.dstComponentId.empty() ||
+        args.tw <= 0 || args.th <= 0 ||
+        static_cast<size_t>(args.tw) > std::numeric_limits<size_t>::max() / static_cast<size_t>(args.th) ||
+        static_cast<size_t>(args.tw) * static_cast<size_t>(args.th) >
+            static_cast<size_t>(std::numeric_limits<int>::max()) / 4U) {
+        return;
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::gCanvasDrawCanvas2Canvas(args.dstComponentId, args.tw, args.th, args.srcComponentId,
+                                   args.sx, args.sy, args.sw, args.sh,
+                                   args.dx, args.dy, args.dw, args.dh);
+}
+
+void GCanvasEngine::BindImageTexture(const std::string &refId, int32_t imageId,
+                                     const void *pixels, int32_t width, int32_t height) {
+    size_t byteLength = 0;
+    if (!IsValidImage(pixels, width, height, byteLength)) {
+        return;
+    }
+    CacheImage(imageId, pixels, width, height);
+
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        CanvasSurface &surface = surfaces_[refId];
+        surface.componentId = refId;
+        ready = surface.isReady;
+        if (!ready && std::find(surface.pendingImageIds.begin(), surface.pendingImageIds.end(), imageId) ==
+            surface.pendingImageIds.end()) {
+            surface.pendingImageIds.push_back(imageId);
+        }
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasBindTexture(pixels, width, height, refId, imageId);
+    }
+}
+
+bool GCanvasEngine::BindCachedImageTextureInternal(const std::string &refId, int32_t imageId,
+                                                   bool queueWhenNotReady) {
+    CachedImage image;
+    bool ready = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto imageIt = imageCache_.find(imageId);
+        if (imageIt == imageCache_.end()) {
+            return false;
+        }
+        image = imageIt->second;
+        CanvasSurface &surface = surfaces_[refId];
+        surface.componentId = refId;
+        ready = surface.isReady;
+        if (!ready && queueWhenNotReady &&
+            std::find(surface.pendingImageIds.begin(), surface.pendingImageIds.end(), imageId) ==
+                surface.pendingImageIds.end()) {
+            surface.pendingImageIds.push_back(imageId);
+        }
+    }
+    if (ready) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        rnoh::gCanvasBindTexture(image.pixels.data(), image.width, image.height, refId, imageId);
+    }
+    return true;
+}
+
+bool GCanvasEngine::BindCachedImageTexture(const std::string &refId, int32_t imageId) {
+    return BindCachedImageTextureInternal(refId, imageId, true);
+}
+
+void GCanvasEngine::CacheImage(int32_t id, const void *pixels, int32_t width, int32_t height) {
+    size_t byteLength = 0;
+    if (!IsValidImage(pixels, width, height, byteLength)) {
+        return;
+    }
+    CachedImage image;
+    image.width = width;
+    image.height = height;
+    const auto *begin = static_cast<const uint8_t *>(pixels);
+    image.pixels.assign(begin, begin + byteLength);
+    std::lock_guard<std::mutex> lock(mutex_);
+    imageCache_[id] = std::move(image);
+}
+
+std::string GCanvasEngine::MakeTextureCommand(bool isSub, int32_t target, int32_t level,
+                                              int32_t internalformat, int32_t format, int32_t type,
+                                              int32_t xoffset, int32_t yoffset,
+                                              const void *pixels, int32_t width, int32_t height) {
+    size_t byteLength = 0;
+    if (!IsValidImage(pixels, width, height, byteLength)) {
+        return "";
+    }
+    const auto *bytes = static_cast<const uint8_t *>(pixels);
+    std::string values;
+    values.reserve(byteLength * 4U);
+    for (size_t index = 0; index < byteLength; ++index) {
+        values += std::to_string(bytes[index]);
+        if (index + 1U < byteLength) {
+            values.push_back(',');
+        }
+    }
+    if (values.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+        return "";
+    }
+    int valueLength = static_cast<int>(values.size());
+    std::string encoded(static_cast<size_t>(Base64EncodeLen(valueLength)), '\0');
+    Base64EncodeBuf(encoded.data(), values.data(), valueLength);
+    encoded.resize(static_cast<size_t>(valueLength));
+
+    std::ostringstream command;
+    if (isSub) {
+        command << "105,9," << target << ',' << level << ',' << xoffset << ',' << yoffset << ','
+                << width << ',' << height << ',' << format << ',' << type << ",1," << encoded;
+    } else {
+        command << "102,9," << target << ',' << level << ',' << internalformat << ','
+                << width << ',' << height << ",0," << format << ',' << type << ",1," << encoded;
+    }
+    return command.str();
+}
+
+void GCanvasEngine::TexImage2D(const std::string &refId, int32_t target, int32_t level,
+                               int32_t internalformat, int32_t format, int32_t type,
+                               const void *pixels, int32_t width, int32_t height) {
+    const std::string command = MakeTextureCommand(false, target, level, internalformat, format, type,
+                                                   0, 0, pixels, width, height);
+    if (!command.empty()) {
+        Render(refId, command, WEBGL_ASYNC_TYPE);
+    }
+}
+
+void GCanvasEngine::TexSubImage2D(const std::string &refId, int32_t target, int32_t level,
+                                  int32_t xoffset, int32_t yoffset, int32_t format, int32_t type,
+                                  const void *pixels, int32_t width, int32_t height) {
+    const std::string command = MakeTextureCommand(true, target, level, 0, format, type,
+                                                   xoffset, yoffset, pixels, width, height);
+    if (!command.empty()) {
+        Render(refId, command, WEBGL_ASYNC_TYPE);
+    }
+}
+
+void GCanvasEngine::AddFontFamily(const std::vector<std::string> &fontNames,
+                                  const std::vector<std::string> &fontFiles) {
+    InitializeSystemFonts();
+    const size_t count = std::min(fontNames.size(), fontFiles.size());
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    for (size_t index = 0; index < count; ++index) {
+        InsertFontWithAliases(fontNames[index], fontFiles[index]);
+    }
+}
+
+std::vector<std::string> GCanvasEngine::GetFontNames() {
+    InitializeSystemFonts();
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    std::vector<std::string> names = rnoh::glGetFontNames();
+    std::sort(names.begin(), names.end());
+    names.erase(std::unique(names.begin(), names.end()), names.end());
+    return names;
+}
+
+void GCanvasEngine::SetExtraFontLocation(const std::string &location) {
+    if (location.empty()) {
+        return;
+    }
+    std::string normalized = location;
+    if (normalized.back() != '/') {
+        normalized.push_back('/');
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::glSetExtraFontLocation(normalized);
+}
+
+std::string GCanvasEngine::GetDeviceInfo(const std::string &args) {
+    (void)args;
+    return "{\"platform\":\"harmony\",\"renderer\":\"GCanvas\"}";
+}
+
+void GCanvasEngine::SetLogLevel(int32_t level) {
+    const int32_t clamped = std::clamp(level, static_cast<int32_t>(LOG_LEVEL_DEBUG),
+                                      static_cast<int32_t>(LOG_LEVEL_FATAL));
+    ::SetLogLevel(static_cast<GLogLevel>(clamped));
+}
+
+void GCanvasEngine::ResetComponent(const std::string &refId) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(refId);
+        if (it != surfaces_.end()) {
+            it->second.pendingRenders.clear();
+            it->second.pendingImageIds.clear();
+        }
+    }
+    std::lock_guard<std::mutex> coreLock(coreMutex_);
+    rnoh::glResetComponent(refId);
+}
+
+void GCanvasEngine::FlushPending(const std::string &componentId) {
+    std::vector<PendingRender> renders;
+    std::vector<int32_t> imageIds;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = surfaces_.find(componentId);
+        if (it == surfaces_.end() || !it->second.isReady) {
+            return;
+        }
+        renders.swap(it->second.pendingRenders);
+        imageIds.swap(it->second.pendingImageIds);
+    }
+
+    for (int32_t imageId : imageIds) {
+        (void)BindCachedImageTextureInternal(componentId, imageId, false);
+    }
+    for (const auto &render : renders) {
+        std::lock_guard<std::mutex> coreLock(coreMutex_);
+        (void)rnoh::gCanvasRender(componentId, render.command, render.type);
+    }
+}
+
+} // namespace gcanvas