react-native-nitro-zxing 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,34 @@
+# react-native-nitro-zxing
+
+A [VisionCamera](https://github.com/mrousavy/react-native-vision-camera) v5 barcode scanner powered by [zxing-cpp](https://github.com/zxing-cpp/zxing-cpp), implemented as pure C++ Nitro HybridObjects. Frames are decoded straight from the camera's pixel buffer (Y plane, zero-copy) - no ML Kit, no base64, no temporary files.
+
+```sh
+npm install react-native-nitro-zxing react-native-nitro-image
+```
+
+Requires VisionCamera Core, Nitro Modules and Nitro Image. For frame processors also install `react-native-vision-camera-worklets` and `react-native-worklets`.
+
+```ts
+import { useBarcodeScanner } from 'react-native-nitro-zxing'
+
+const scanner = useBarcodeScanner({ barcodeFormats: ['all-formats'] })
+const frameOutput = useFrameOutput({
+  pixelFormat: 'yuv',
+  onFrame(frame) {
+    'worklet'
+    const barcodes = scanner.scanCodes(frame)
+    frame.dispose()
+    console.log(barcodes.map((b) => `${b.format}: ${b.displayValue}`))
+  },
+})
+```
+
+Still images: `await scanner.scanCodesInImageAsync(image)` with a Nitro `Image`.
+
+## Building from source
+
+zxing-cpp is vendored as a git submodule at `cpp/zxing-core`. When cloning the repository run `git submodule update --init`; the npm package already contains the sources.
+
+## Coordinates
+
+`Barcode.cornerPoints` / `boundingBox` are in the upright (rotated by `Frame.orientation`) frame coordinate system, matching `react-native-vision-camera-barcode-scanner`.

package/VisionCameraZxing.podspec

@@ -0,0 +1,48 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "VisionCameraZxing"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/margelo/react-native-vision-camera-zxing.git", :tag => "v#{s.version}" }
+
+  s.source_files = [
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/*.{hpp,cpp}",
+    # zxing-cpp readers (git submodule)
+    "cpp/zxing-core/core/src/**/*.{h,c,cpp}",
+  ]
+  s.exclude_files = [
+    "cpp/zxing-core/core/src/libzint/**",
+    "cpp/zxing-core/core/src/ZXingC.cpp",
+  ]
+  s.private_header_files = [
+    "cpp/*.hpp",
+    "cpp/zxing-core/core/src/**/*.h",
+  ]
+  s.compiler_flags = "-DZXING_INTERNAL -Wno-comma"
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => '"$(PODS_TARGET_SRCROOT)/cpp/zxing-core/core/src" "$(PODS_TARGET_SRCROOT)/cpp/zxing-core/wrappers/ios/Sources/Wrapper"',
+    # Header maps resolve by basename across all pods (e.g. React's Point.h or another
+    # barcode pod's BarcodeFormat.hpp would shadow ours); use the search paths above instead.
+    "USE_HEADERMAP" => "NO",
+  }
+
+  load 'nitrogen/generated/ios/VisionCameraZxing+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'VisionCamera'
+  s.dependency 'NitroImage'
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,43 @@
+project(VisionCameraZxing)
+cmake_minimum_required(VERSION 3.16.0)
+
+set (PACKAGE_NAME VisionCameraZxing)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# zxing-cpp readers only, as a static archive linked into our shared library
+set (ZXING_READERS ON)
+set (ZXING_WRITERS OFF)
+set (BUILD_SHARED_LIBS OFF)
+add_subdirectory(${CMAKE_SOURCE_DIR}/../cpp/zxing-core/core ${CMAKE_BINARY_DIR}/zxing-core EXCLUDE_FROM_ALL)
+
+file(GLOB SHARED_CPP_SOURCES CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/../cpp/*.cpp")
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+        ${SHARED_CPP_SOURCES}
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/VisionCameraZxing+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+find_package(react-native-vision-camera REQUIRED)   # <-- for the HybridFrameSpec
+find_package(react-native-nitro-image REQUIRED)     # <-- for the HybridImageSpec
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+        ZXing::ZXing
+        react-native-vision-camera::VisionCamera
+        react-native-nitro-image::NitroImage
+)

package/android/build.gradle

@@ -0,0 +1,150 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:9.2.1"
+  }
+}
+
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/VisionCameraZxing+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["VisionCameraZxing_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["VisionCameraZxing_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.camera.zxing"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libNitroModules.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  // Add a dependency on VisionCamera (for HybridFrameSpec and HybridCameraOutputSpec)
+  implementation project(":react-native-vision-camera")
+
+  // Add a dependency on NitroImage (for HybridImageSpec)
+  implementation project(":react-native-nitro-image")
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+VisionCameraZxing_kotlinVersion=2.2.21
+VisionCameraZxing_minSdkVersion=23
+VisionCameraZxing_targetSdkVersion=36
+VisionCameraZxing_compileSdkVersion=36
+VisionCameraZxing_ndkVersion=29.0.14206865

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-feature android:name="android.hardware.camera" android:required="false" />
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,7 @@
+#include "VisionCameraZxingOnLoad.hpp"
+#include <fbjni/fbjni.h>
+#include <jni.h>
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() { margelo::nitro::camera::zxing::registerAllNatives(); });
+}

package/android/src/main/java/com/margelo/nitro/camera/zxing/VisionCameraZxingPackage.kt

@@ -0,0 +1,21 @@
+package com.margelo.nitro.camera.zxing
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class VisionCameraZxingPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+  companion object {
+    init {
+      VisionCameraZxingOnLoad.initializeNative()
+    }
+  }
+}

package/cpp/BarcodeValueTypeClassifier.cpp

@@ -0,0 +1,70 @@
+#include "BarcodeValueTypeClassifier.hpp"
+
+#include <cctype>
+
+namespace margelo::nitro::camera::zxing {
+
+namespace {
+
+  bool startsWithIgnoreCase(std::string_view text, std::string_view prefix) {
+    if (text.size() < prefix.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < prefix.size(); i++) {
+      const int textChar = std::tolower(static_cast<unsigned char>(text[i]));
+      const int prefixChar = std::tolower(static_cast<unsigned char>(prefix[i]));
+      if (textChar != prefixChar) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool isRetailFormat(BarcodeFormat format) {
+    return format == BarcodeFormat::EAN_13 || format == BarcodeFormat::EAN_8 || format == BarcodeFormat::UPC_A || format == BarcodeFormat::UPC_E;
+  }
+
+} // namespace
+
+// ponytail: prefix heuristic mirroring ML Kit's value types, no vCard/WiFi/vEvent parsing.
+BarcodeValueType classifyValueType(std::string_view text, BarcodeFormat format, ZXing::ContentType contentType) {
+  if (contentType == ZXing::ContentType::Binary) {
+    return BarcodeValueType::UNKNOWN;
+  }
+  if (startsWithIgnoreCase(text, "http://") || startsWithIgnoreCase(text, "https://")) {
+    return BarcodeValueType::URL;
+  }
+  if (startsWithIgnoreCase(text, "mailto:") || startsWithIgnoreCase(text, "MATMSG:")) {
+    return BarcodeValueType::EMAIL;
+  }
+  if (startsWithIgnoreCase(text, "tel:")) {
+    return BarcodeValueType::PHONE;
+  }
+  if (startsWithIgnoreCase(text, "smsto:") || startsWithIgnoreCase(text, "sms:")) {
+    return BarcodeValueType::SMS;
+  }
+  if (startsWithIgnoreCase(text, "geo:")) {
+    return BarcodeValueType::GEO;
+  }
+  if (startsWithIgnoreCase(text, "WIFI:")) {
+    return BarcodeValueType::WIFI;
+  }
+  if (startsWithIgnoreCase(text, "BEGIN:VCARD") || startsWithIgnoreCase(text, "MECARD:")) {
+    return BarcodeValueType::CONTACT_INFO;
+  }
+  if (startsWithIgnoreCase(text, "BEGIN:VEVENT") || startsWithIgnoreCase(text, "BEGIN:VCALENDAR")) {
+    return BarcodeValueType::CALENDAR_EVENT;
+  }
+  if (format == BarcodeFormat::PDF_417 && text.starts_with("@\n")) {
+    return BarcodeValueType::DRIVER_LICENSE;
+  }
+  if (format == BarcodeFormat::EAN_13 && (text.starts_with("978") || text.starts_with("979"))) {
+    return BarcodeValueType::ISBN;
+  }
+  if (isRetailFormat(format)) {
+    return BarcodeValueType::PRODUCT;
+  }
+  return BarcodeValueType::TEXT;
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/BarcodeValueTypeClassifier.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "BarcodeFormat.hpp"
+#include "BarcodeValueType.hpp"
+
+#include "ContentType.h"
+
+#include <string_view>
+
+namespace margelo::nitro::camera::zxing {
+
+BarcodeValueType classifyValueType(std::string_view plainText, BarcodeFormat format, ZXing::ContentType contentType);
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/FrameImageView.cpp

@@ -0,0 +1,75 @@
+#include "FrameImageView.hpp"
+
+#include <stdexcept>
+#include <string>
+
+namespace margelo::nitro::camera::zxing {
+
+namespace {
+
+  // Clockwise rotation that makes the buffer upright: `orientation` describes how the content is
+  // currently rotated (VisionCamera maps CameraX's rotationDegrees=90 to LEFT), so we rotate back.
+  int rotationDegrees(camera::CameraOrientation orientation) {
+    switch (orientation) {
+      case camera::CameraOrientation::UP:
+        return 0;
+      case camera::CameraOrientation::LEFT:
+        return 90;
+      case camera::CameraOrientation::DOWN:
+        return 180;
+      case camera::CameraOrientation::RIGHT:
+        return 270;
+    }
+    return 0;
+  }
+
+} // namespace
+
+FrameImageView::FrameImageView(const std::shared_ptr<camera::HybridFrameSpec>& frame) : _frame(frame) {
+  if (frame == nullptr || !frame->getIsValid()) {
+    throw std::runtime_error("The given Frame is invalid or has already been disposed!");
+  }
+  const int width = static_cast<int>(frame->getWidth());
+  const int height = static_cast<int>(frame->getHeight());
+  const camera::PixelFormat pixelFormat = frame->getPixelFormat();
+
+  switch (pixelFormat) {
+    case camera::PixelFormat::YUV_420_8_BIT_VIDEO:
+    case camera::PixelFormat::YUV_420_8_BIT_FULL: {
+      // Luminance is plane 0 - read it in place, no conversion needed.
+      _planes = frame->getPlanes();
+      if (_planes.empty()) {
+        throw std::runtime_error("The given YUV Frame has no planes!");
+      }
+      _buffer = _planes[0]->getPixelBuffer();
+      const int rowStride = static_cast<int>(_planes[0]->getBytesPerRow());
+      const uint8_t* data = _buffer->data();
+      _view = ZXing::ImageView(data, width, height, ZXing::ImageFormat::Lum, rowStride);
+      break;
+    }
+    case camera::PixelFormat::RGB_BGRA_8_BIT:
+    case camera::PixelFormat::RGB_RGBA_8_BIT:
+    case camera::PixelFormat::RGB_RGB_8_BIT: {
+      _buffer = frame->getPixelBuffer();
+      const int rowStride = static_cast<int>(frame->getBytesPerRow());
+      ZXing::ImageFormat format = ZXing::ImageFormat::RGB;
+      if (pixelFormat == camera::PixelFormat::RGB_BGRA_8_BIT) {
+        format = ZXing::ImageFormat::BGRA;
+      } else if (pixelFormat == camera::PixelFormat::RGB_RGBA_8_BIT) {
+        format = ZXing::ImageFormat::RGBA;
+      }
+      const uint8_t* data = _buffer->data();
+      _view = ZXing::ImageView(data, width, height, format, rowStride);
+      break;
+    }
+    default:
+      throw std::runtime_error("Unsupported Frame pixelFormat (" + std::to_string(static_cast<int>(pixelFormat)) +
+                               ")! Use a Frame Output with pixelFormat 'yuv' or 'rgb'.");
+  }
+
+  // ponytail: isMirrored is ignored - zxing decodes mirrored symbols and the ML Kit reference ignores it on Android too.
+  const int rotation = rotationDegrees(frame->getOrientation());
+  _view = _view.rotated(rotation);
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/FrameImageView.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "ImageView.h"
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <VisionCamera/HybridFramePlaneSpec.hpp>
+#include <VisionCamera/HybridFrameSpec.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace margelo::nitro::camera::zxing {
+
+/**
+ * Wraps a VisionCamera `Frame` as a zero-copy `ZXing::ImageView`, rotated upright by the Frame's orientation.
+ * Keeps the Frame, its planes and the pixel `ArrayBuffer` alive for as long as this object lives.
+ * All calls into the Frame happen in the constructor, so the Frame must still be valid when it runs.
+ */
+class FrameImageView final {
+public:
+  explicit FrameImageView(const std::shared_ptr<camera::HybridFrameSpec>& frame);
+
+  const ZXing::ImageView& imageView() const noexcept {
+    return _view;
+  }
+
+private:
+  std::shared_ptr<camera::HybridFrameSpec> _frame;
+  std::vector<std::shared_ptr<camera::HybridFramePlaneSpec>> _planes;
+  std::shared_ptr<ArrayBuffer> _buffer;
+  ZXing::ImageView _view;
+};
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/HybridBarcode.cpp

@@ -0,0 +1,59 @@
+#include "HybridBarcode.hpp"
+
+#include <algorithm>
+
+namespace margelo::nitro::camera::zxing {
+
+BarcodeFormat HybridBarcode::getFormat() {
+  return _barcode.format;
+}
+
+Rect HybridBarcode::getBoundingBox() {
+  const auto& corners = _barcode.corners;
+  auto [minX, maxX] = std::minmax({corners[0].x, corners[1].x, corners[2].x, corners[3].x});
+  auto [minY, maxY] = std::minmax({corners[0].y, corners[1].y, corners[2].y, corners[3].y});
+  return Rect(minX, maxX, minY, maxY);
+}
+
+std::vector<Point> HybridBarcode::getCornerPoints() {
+  std::vector<Point> points;
+  points.reserve(_barcode.corners.size());
+  for (const ZXing::PointI& corner : _barcode.corners) {
+    points.emplace_back(corner.x, corner.y);
+  }
+  return points;
+}
+
+std::optional<std::string> HybridBarcode::getDisplayValue() {
+  if (_barcode.displayValue.empty()) {
+    return std::nullopt;
+  }
+  return _barcode.displayValue;
+}
+
+std::optional<std::shared_ptr<ArrayBuffer>> HybridBarcode::getRawBytes() {
+  if (_barcode.rawBytes.empty()) {
+    return std::nullopt;
+  }
+  if (_rawBytes == nullptr) {
+    _rawBytes = ArrayBuffer::copy(_barcode.rawBytes);
+  }
+  return _rawBytes;
+}
+
+std::optional<std::string> HybridBarcode::getRawValue() {
+  if (_barcode.rawValue.empty()) {
+    return std::nullopt;
+  }
+  return _barcode.rawValue;
+}
+
+BarcodeValueType HybridBarcode::getValueType() {
+  return _barcode.valueType;
+}
+
+size_t HybridBarcode::getExternalMemorySize() noexcept {
+  return _barcode.rawBytes.size() + _barcode.rawValue.size() + _barcode.displayValue.size();
+}
+
+} // namespace margelo::nitro::camera::zxing

package/cpp/HybridBarcode.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "HybridBarcodeSpec.hpp"
+#include "ZXingDecoder.hpp"
+
+namespace margelo::nitro::camera::zxing {
+
+class HybridBarcode final : public HybridBarcodeSpec {
+public:
+  explicit HybridBarcode(DecodedBarcode barcode) : HybridObject(TAG), _barcode(std::move(barcode)) {}
+
+  BarcodeFormat getFormat() override;
+  Rect getBoundingBox() override;
+  std::vector<Point> getCornerPoints() override;
+  std::optional<std::string> getDisplayValue() override;
+  std::optional<std::shared_ptr<ArrayBuffer>> getRawBytes() override;
+  std::optional<std::string> getRawValue() override;
+  BarcodeValueType getValueType() override;
+  size_t getExternalMemorySize() noexcept override;
+
+private:
+  DecodedBarcode _barcode;
+  std::shared_ptr<ArrayBuffer> _rawBytes;
+};
+
+} // namespace margelo::nitro::camera::zxing