@onekeyfe/react-native-image 3.0.98

package/ios/tests/OneKeyTosURLTests.swift

@@ -0,0 +1,142 @@
+import XCTest
+
+@testable import OneKeyImage
+
+final class OneKeyTosURLTests: XCTestCase {
+  func testOptimizesAllowedOneKeyAssetURL() throws {
+    let raw = try XCTUnwrap(URL(string: "https://common.onekey-asset.com/tokens/btc.png"))
+    let result = OneKeyTosURL.optimized(
+      rawURL: raw,
+      displaySize: 100,
+      scale: 2,
+      overscan: 1.1,
+      hasCustomIdentity: false
+    )
+    XCTAssertTrue(result.absoluteString.contains("x-tos-process="))
+    XCTAssertTrue(result.absoluteString.contains("w_256"))
+  }
+
+  func testDoesNotRewriteSignedOrCustomIdentityURL() throws {
+    let signed = try XCTUnwrap(
+      URL(string: "https://common.onekey-asset.com/avatar.png?X-Tos-Signature=secret")
+    )
+    XCTAssertEqual(
+      OneKeyTosURL.optimized(
+        rawURL: signed,
+        displaySize: 100,
+        scale: 2,
+        overscan: 1.1,
+        hasCustomIdentity: false
+      ),
+      signed
+    )
+    let raw = try XCTUnwrap(URL(string: "https://common.onekey-asset.com/avatar.png"))
+    XCTAssertEqual(
+      OneKeyTosURL.optimized(
+        rawURL: raw,
+        displaySize: 100,
+        scale: 2,
+        overscan: 1.1,
+        hasCustomIdentity: true
+      ),
+      raw
+    )
+  }
+
+  func testDoesNotRewriteUntrustedHostOrUnsupportedMedia() throws {
+    for value in [
+      "https://example.com/avatar.png",
+      "https://web.onekey-asset.com/avatar.png",
+      "https://common.onekey-asset.com/icon.svg",
+      "https://common.onekey-asset.com/video.mp4",
+      "https://common.onekey-asset.com/video.webm",
+      "https://common.onekey-asset.com/video.m4v",
+      "https://common.onekey-asset.com/video.mov",
+      "https://common.onekey-asset.com/video.avi",
+    ] {
+      let raw = try XCTUnwrap(URL(string: value))
+      XCTAssertEqual(
+        OneKeyTosURL.optimized(
+          rawURL: raw,
+          displaySize: 100,
+          scale: 2,
+          overscan: 1.1,
+          hasCustomIdentity: false
+        ),
+        raw
+      )
+    }
+  }
+
+  func testUsesApprovedHostsBucketsAndCapsDPR() throws {
+    for host in [
+      "app-assets.onekey.so",
+      "uni.onekey-asset.com",
+      "uni-test.onekey-asset.com",
+      "common.onekey-asset.com",
+      "asset.onekey-asset.com",
+    ] {
+      let raw = try XCTUnwrap(URL(string: "https://\(host)/token.png"))
+      let result = OneKeyTosURL.optimized(
+        rawURL: raw,
+        displaySize: 100,
+        scale: 5,
+        overscan: 1.1,
+        hasCustomIdentity: false
+      )
+      XCTAssertTrue(result.absoluteString.contains("w_480"))
+    }
+  }
+
+  func testNormalizesNonFiniteSizingInputsWithoutCrashing() throws {
+    let raw = try XCTUnwrap(URL(string: "https://common.onekey-asset.com/token.png"))
+    let result = OneKeyTosURL.optimized(
+      rawURL: raw,
+      displaySize: 100,
+      scale: .nan,
+      overscan: .infinity,
+      hasCustomIdentity: false
+    )
+    XCTAssertTrue(result.absoluteString.contains("w_128"))
+    XCTAssertEqual(
+      OneKeyTosURL.optimized(
+        rawURL: raw,
+        displaySize: .infinity,
+        scale: 2,
+        overscan: 1.1,
+        hasCustomIdentity: false
+      ),
+      raw
+    )
+    let huge = OneKeyTosURL.optimized(
+      rawURL: raw,
+      displaySize: .greatestFiniteMagnitude,
+      scale: 3,
+      overscan: 1.1,
+      hasCustomIdentity: false
+    )
+    XCTAssertTrue(huge.absoluteString.contains("w_1280"))
+  }
+
+  func testSkipsEveryProtectedQueryFamily() throws {
+    for key in [
+      "expires", "policy", "signature", "token", "auth_key", "accesskeyid",
+      "ossaccesskeyid", "security-token", "x-amz-signature", "x-oss-signature",
+      "x-tos-process",
+    ] {
+      let raw = try XCTUnwrap(
+        URL(string: "https://common.onekey-asset.com/token.png?\(key)=value")
+      )
+      XCTAssertEqual(
+        OneKeyTosURL.optimized(
+          rawURL: raw,
+          displaySize: 100,
+          scale: 2,
+          overscan: 1.1,
+          hasCustomIdentity: false
+        ),
+        raw
+      )
+    }
+  }
+}

package/lib/module/OneKeyImage.nitro.js

@@ -0,0 +1,30 @@
+"use strict";
+
+export let OneKeyImageVariant = /*#__PURE__*/function (OneKeyImageVariant) {
+  OneKeyImageVariant["GENERIC"] = "generic";
+  OneKeyImageVariant["TOKEN"] = "token";
+  OneKeyImageVariant["NETWORK"] = "network";
+  OneKeyImageVariant["AVATAR"] = "avatar";
+  return OneKeyImageVariant;
+}({});
+export let OneKeyImageContentFit = /*#__PURE__*/function (OneKeyImageContentFit) {
+  OneKeyImageContentFit["COVER"] = "cover";
+  OneKeyImageContentFit["CONTAIN"] = "contain";
+  OneKeyImageContentFit["FILL"] = "fill";
+  OneKeyImageContentFit["CENTER"] = "center";
+  return OneKeyImageContentFit;
+}({});
+export let OneKeyImageCachePolicy = /*#__PURE__*/function (OneKeyImageCachePolicy) {
+  OneKeyImageCachePolicy["MEMORY_DISK"] = "memory-disk";
+  OneKeyImageCachePolicy["MEMORY"] = "memory";
+  OneKeyImageCachePolicy["DISK"] = "disk";
+  OneKeyImageCachePolicy["NONE"] = "none";
+  return OneKeyImageCachePolicy;
+}({});
+export let OneKeyImageLoadingStrategy = /*#__PURE__*/function (OneKeyImageLoadingStrategy) {
+  OneKeyImageLoadingStrategy["STATIC"] = "static";
+  OneKeyImageLoadingStrategy["SKELETON"] = "skeleton";
+  OneKeyImageLoadingStrategy["NONE"] = "none";
+  return OneKeyImageLoadingStrategy;
+}({});
+//# sourceMappingURL=OneKeyImage.nitro.js.map

package/lib/module/index.js

@@ -0,0 +1,223 @@
+"use strict";
+
+import { createElement, useEffect, useMemo, useRef, useState } from 'react';
+import { Image, Platform, StyleSheet, View } from 'react-native';
+import { callback, getHostComponent, NitroModules } from 'react-native-nitro-modules';
+const OneKeyImageConfig = require('../nitrogen/generated/shared/json/OneKeyImageConfig.json');
+import { OneKeyImageCachePolicy, OneKeyImageContentFit, OneKeyImageLoadingStrategy, OneKeyImageVariant } from "./OneKeyImage.nitro.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export { OneKeyImageCachePolicy, OneKeyImageContentFit, OneKeyImageLoadingStrategy, OneKeyImageVariant };
+export let OneKeyImageCacheType = /*#__PURE__*/function (OneKeyImageCacheType) {
+  OneKeyImageCacheType["NONE"] = "none";
+  OneKeyImageCacheType["MEMORY"] = "memory";
+  OneKeyImageCacheType["DISK"] = "disk";
+  return OneKeyImageCacheType;
+}({});
+const NativeOneKeyImage = getHostComponent('OneKeyImage', () => OneKeyImageConfig);
+const nativeCache = NitroModules.createHybridObject('OneKeyImageCache');
+function unwrap(value) {
+  return typeof value === 'function' ? value : value?.f;
+}
+function normalizeSource(source) {
+  if (source == null) return undefined;
+  const resolved = Image.resolveAssetSource(source);
+  if (resolved?.uri) {
+    const original = typeof source === 'object' && !Array.isArray(source) ? source : undefined;
+    return {
+      uri: resolved.uri,
+      width: resolved.width,
+      height: resolved.height,
+      scale: resolved.scale,
+      headers: original?.headers,
+      cachePolicy: original?.cachePolicy
+    };
+  }
+  return undefined;
+}
+export function OneKeyImage({
+  source,
+  placeholder,
+  fallback,
+  variant = OneKeyImageVariant.GENERIC,
+  contentFit = OneKeyImageContentFit.COVER,
+  cachePolicy,
+  autoplay,
+  recyclingKey,
+  optimizeTos = true,
+  overscan = 1.1,
+  loadingStrategy = OneKeyImageLoadingStrategy.STATIC,
+  hybridRef,
+  onLoadStart,
+  onLoad,
+  onDisplay,
+  onError,
+  onLoadEnd,
+  style,
+  ...viewProps
+}) {
+  const normalized = useMemo(() => normalizeSource(source), [source]);
+  const resolvedCachePolicy = cachePolicy ?? normalized?.cachePolicy ?? OneKeyImageCachePolicy.MEMORY_DISK;
+  const identity = `${normalized?.uri ?? ''}|${JSON.stringify(normalized?.headers ?? {})}|${resolvedCachePolicy}|${recyclingKey ?? ''}|${contentFit}|${optimizeTos ? '1' : '0'}|${overscan}`;
+  const hasSource = normalized != null;
+  const hasOverlay = placeholder != null || fallback != null;
+  const [loadState, setLoadState] = useState({
+    identity,
+    status: hasSource ? 'loading' : 'fallback'
+  });
+  const effectiveState = loadState.identity === identity ? loadState.status : hasSource ? 'loading' : 'fallback';
+  const refs = useRef({
+    hybridRef: unwrap(hybridRef),
+    onLoadStart: unwrap(onLoadStart),
+    onLoad: unwrap(onLoad),
+    onDisplay: unwrap(onDisplay),
+    onError: unwrap(onError),
+    onLoadEnd: unwrap(onLoadEnd)
+  });
+  refs.current = {
+    hybridRef: unwrap(hybridRef),
+    onLoadStart: unwrap(onLoadStart),
+    onLoad: unwrap(onLoad),
+    onDisplay: unwrap(onDisplay),
+    onError: unwrap(onError),
+    onLoadEnd: unwrap(onLoadEnd)
+  };
+  const nativeMethodsRef = useRef(null);
+  const pendingOverlayReloadRef = useRef(null);
+  const previousRenderRef = useRef({
+    hasOverlay,
+    identity
+  });
+  useEffect(() => {
+    const previous = previousRenderRef.current;
+    const identityChanged = previous.identity !== identity;
+    if (hasOverlay && (!previous.hasOverlay || identityChanged)) {
+      const status = hasSource ? 'loading' : 'fallback';
+      setLoadState({
+        identity,
+        status
+      });
+    }
+    if (hasOverlay && !previous.hasOverlay && !identityChanged && hasSource) {
+      pendingOverlayReloadRef.current = identity;
+      const nativeMethods = nativeMethodsRef.current;
+      if (nativeMethods != null) {
+        pendingOverlayReloadRef.current = null;
+        nativeMethods.reload();
+      }
+    } else if (!hasOverlay || identityChanged) {
+      pendingOverlayReloadRef.current = null;
+    }
+    previousRenderRef.current = {
+      hasOverlay,
+      identity
+    };
+  }, [hasOverlay, hasSource, identity]);
+  const needsHybridRef = hasOverlay || refs.current.hybridRef != null;
+  const needsLoadStart = hasOverlay || refs.current.onLoadStart != null;
+  const needsLoad = refs.current.onLoad != null;
+  const needsDisplay = placeholder != null || refs.current.onDisplay != null;
+  const needsError = hasOverlay || refs.current.onError != null;
+  const needsLoadEnd = refs.current.onLoadEnd != null;
+  const nativeCallbacks = useMemo(() => ({
+    hybridRef: needsHybridRef ? callback(ref => {
+      nativeMethodsRef.current = ref;
+      if (pendingOverlayReloadRef.current === identity) {
+        pendingOverlayReloadRef.current = null;
+        ref.reload();
+      }
+      refs.current.hybridRef?.(ref);
+    }) : undefined,
+    onLoadStart: needsLoadStart ? callback(() => {
+      if (hasOverlay) {
+        setLoadState({
+          identity,
+          status: 'loading'
+        });
+      }
+      refs.current.onLoadStart?.();
+    }) : undefined,
+    onLoad: needsLoad ? callback((width, height, cacheType) => {
+      refs.current.onLoad?.({
+        source: {
+          url: normalized?.uri ?? '',
+          width,
+          height
+        },
+        cacheType: cacheType
+      });
+    }) : undefined,
+    onDisplay: needsDisplay ? callback(() => {
+      if (placeholder != null) {
+        setLoadState({
+          identity,
+          status: 'loaded'
+        });
+      }
+      refs.current.onDisplay?.();
+    }) : undefined,
+    onError: needsError ? callback(message => {
+      if (hasOverlay) {
+        setLoadState({
+          identity,
+          status: 'fallback'
+        });
+      }
+      refs.current.onError?.({
+        error: message
+      });
+    }) : undefined,
+    onLoadEnd: needsLoadEnd ? callback(() => refs.current.onLoadEnd?.()) : undefined
+  }), [hasOverlay, identity, needsDisplay, needsError, needsHybridRef, needsLoad, needsLoadEnd, needsLoadStart, normalized?.uri, placeholder]);
+  const native = /*#__PURE__*/createElement(NativeOneKeyImage, {
+    ...viewProps,
+    ...nativeCallbacks,
+    style: hasOverlay ? StyleSheet.absoluteFill : style,
+    sourceUri: normalized?.uri,
+    sourceHeadersJson: normalized?.headers ? JSON.stringify(normalized.headers) : undefined,
+    variant,
+    contentFit,
+    cachePolicy: resolvedCachePolicy,
+    autoplay: autoplay ?? Platform.OS !== 'android',
+    recyclingKey,
+    optimizeTos,
+    overscan,
+    loadingStrategy: placeholder == null ? loadingStrategy : OneKeyImageLoadingStrategy.NONE
+  });
+  if (!hasOverlay) return native;
+  return /*#__PURE__*/_jsxs(View, {
+    style: [style, styles.overlayContainer],
+    collapsable: false,
+    children: [native, effectiveState === 'loading' && placeholder != null ? /*#__PURE__*/_jsx(View, {
+      pointerEvents: "none",
+      style: StyleSheet.absoluteFill,
+      children: placeholder
+    }) : null, effectiveState === 'fallback' && fallback != null ? /*#__PURE__*/_jsx(View, {
+      pointerEvents: "none",
+      style: StyleSheet.absoluteFill,
+      children: fallback
+    }) : null]
+  });
+}
+export const OneKeyImageCache = {
+  preload(sources) {
+    return nativeCache.preload(sources.filter(source => Boolean(source.uri)).map(source => ({
+      uri: source.uri,
+      headersJson: source.headers ? JSON.stringify(source.headers) : undefined,
+      cachePolicy: source.cachePolicy ?? OneKeyImageCachePolicy.MEMORY_DISK,
+      resizeWidth: source.resizeWidth,
+      resizeHeight: source.resizeHeight,
+      pixelRatio: source.pixelRatio,
+      overscan: source.overscan,
+      optimizeTos: source.optimizeTos
+    })));
+  },
+  clearMemory: () => nativeCache.clearMemory(),
+  clearDisk: () => nativeCache.clearDisk(),
+  clearAll: () => nativeCache.clearAll()
+};
+const styles = StyleSheet.create({
+  overlayContainer: {
+    overflow: 'hidden'
+  }
+});
+//# sourceMappingURL=index.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JFunc_void_double_double_OneKeyImageCacheType.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_double_double_OneKeyImageCacheType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "OneKeyImageCacheType.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JOneKeyImageCacheType.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(width: Double, height: Double, cacheType: OneKeyImageCacheType) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double_double_OneKeyImageCacheType: public jni::JavaClass<JFunc_void_double_double_OneKeyImageCacheType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_double_double_OneKeyImageCacheType;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double_double_OneKeyImageCacheType` instance holds through JNI.
+     */
+    void invoke(double width, double height, OneKeyImageCacheType cacheType) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* width */, double /* height */, jni::alias_ref<JOneKeyImageCacheType> /* cacheType */)>("invoke");
+      method(self(), width, height, JOneKeyImageCacheType::fromCpp(cacheType));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double_double_OneKeyImageCacheType that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_double_OneKeyImageCacheType_cxx final: public jni::HybridClass<JFunc_void_double_double_OneKeyImageCacheType_cxx, JFunc_void_double_double_OneKeyImageCacheType> {
+  public:
+    static jni::local_ref<JFunc_void_double_double_OneKeyImageCacheType::javaobject> fromCpp(const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& func) {
+      return JFunc_void_double_double_OneKeyImageCacheType_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_double_OneKeyImageCacheType_cxx` instance holds.
+     */
+    void invoke_cxx(double width, double height, jni::alias_ref<JOneKeyImageCacheType> cacheType) {
+      _func(width, height, cacheType->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_double_double_OneKeyImageCacheType_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_double_OneKeyImageCacheType_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_double_OneKeyImageCacheType_cxx(const std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JFunc_void_std__string.hpp

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__string.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(message: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& message) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("invoke");
+      method(self(), jni::make_jstring(message));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* message */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> message) {
+      _func(message->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* message */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* message */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* message */)> _func;
+  };
+
+} // namespace margelo::nitro::onekeyimage