Flutter OCR SDK

https://github.com/yushulx/flutter_ocr_sdk
Admin
A Flutter wrapper for the Dynamsoft Capture Vision SDK, enabling MRZ and VIN detection on Windows,...
Tokens:12,071
Snippets:69
Trust Score:9.2
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Application Files and Libraries

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Defines destination directories for installed components and installs the application executable, Flutter ICU data file, Flutter library, and any bundled plugin libraries into the appropriate locations within the installation bundle.

```CMake
set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")

install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
  COMPONENT Runtime)

foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
  install(FILES "${bundled_library}"
    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endforeach(bundled_library)
```

--------------------------------

### Configure CMake Installation Paths for Runtime

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This snippet defines the installation directories for the application's runtime components. It sets the build bundle directory, ensures the 'install' step is default for Visual Studio, and defines specific paths for data and library files within the installation prefix.

```CMake
# === Installation ===
# Support files are copied into place next to the executable, so that it can
# run in place. This is done instead of making a separate bundle (as on Linux)
# so that building and running from within Visual Studio will work.
set(BUILD_BUNDLE_DIR "$<TARGET_FILE_DIR:${BINARY_NAME}>")
# Make the "install" step default, as it's required to run.
set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1)
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
endif()

set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}")
```

--------------------------------

### Run Flutter Example Project on Various Platforms

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/README.md

This command-line snippet shows how to run the Flutter example project on different target platforms like Web, Linux, Windows, or the default connected device. Navigate to the example directory before executing these commands.

```Bash
cd example
flutter run -d chrome    # Run on Web
flutter run -d linux     # Run on Linux
flutter run -d windows   # Run on Windows
flutter run              # Run on default connected device (e.g., Android)
```

--------------------------------

### Install Plugin Libraries and Resources to Destination Directory

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/linux/CMakeLists.txt

This snippet uses the `install` command to copy specified directories and files to the installation prefix. It currently installs the `linux/lib` directory. The commented-out lines indicate intentions to install various resource directories (Models, ParserResources, Templates) and data files (OverlappingChars.data, ConfusableChars.data) to the plugin's library destination.

```CMake
install(DIRECTORY 
  "${PROJECT_SOURCE_DIR}/../linux/lib/"
  DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
)

# install(DIRECTORY 
#   "${PROJECT_SOURCE_DIR}/../resources/Models"
#   DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
# )

# install(DIRECTORY 
#   "${PROJECT_SOURCE_DIR}/../resources/ParserResources"
#   DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
# )

# install(DIRECTORY 
#   "${PROJECT_SOURCE_DIR}/../resources/Templates"
#   DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
# )

# install(FILES
#   "${PROJECT_SOURCE_DIR}/../resources/OverlappingChars.data"
#   DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
# )

# install(FILES
#   "${PROJECT_SOURCE_DIR}/../resources/ConfusableChars.data"
#   DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/"
# )
```

--------------------------------

### Configure Installation Bundle Directory

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Sets the default installation prefix to a build bundle directory and ensures this directory is cleaned recursively before each installation to prevent stale files.

```CMake
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
endif()

install(CODE "\n  file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")\n  " COMPONENT Runtime)
```

--------------------------------

### Implement a Full-Screen Camera Preview in Flutter

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/camera/README.md

This Flutter example demonstrates how to initialize and display a full-screen camera preview using the 'camera' package. It covers camera initialization, state management for the camera controller, and basic error handling for camera access issues.

```Dart
import 'package:camera/camera.dart';
import 'package:flutter/material.dart';

late List<CameraDescription> _cameras;

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  _cameras = await availableCameras();
  runApp(const CameraApp());
}

/// CameraApp is the Main Application.
class CameraApp extends StatefulWidget {
  /// Default Constructor
  const CameraApp({super.key});

  @override
  State<CameraApp> createState() => _CameraAppState();
}

class _CameraAppState extends State<CameraApp> {
  late CameraController controller;

  @override
  void initState() {
    super.initState();
    controller = CameraController(_cameras[0], ResolutionPreset.max);
    controller.initialize().then((_) {
      if (!mounted) {
        return;
      }
      setState(() {});
    }).catchError((Object e) {
      if (e is CameraException) {
        switch (e.code) {
          case 'CameraAccessDenied':
            // Handle access errors here.
            break;
          default:
            // Handle other errors here.
            break;
        }
      }
    });
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    if (!controller.value.isInitialized) {
      return Container();
    }
    return MaterialApp(
      home: CameraPreview(controller),
    );
  }
}
```

--------------------------------

### Install Application Executable and Core Flutter Files

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This section handles the installation of the main application executable, Flutter's ICU data file, and the core Flutter library. These components are placed into their respective runtime destinations, making the application runnable after installation and ensuring all necessary dependencies are present.

```CMake
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
  COMPONENT Runtime)

install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
  COMPONENT Runtime)

if(PLUGIN_BUNDLED_LIBRARIES)
  install(FILES "${PLUGIN_BUNDLED_LIBRARIES}"
    DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endif()
```

--------------------------------

### Install Flutter Assets and AOT Library with Cleanup

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This snippet manages the installation of Flutter assets, ensuring that the asset directory is fully re-copied on each build to prevent stale files. It also conditionally installs the AOT (Ahead-Of-Time) compiled library for Profile and Release builds, optimizing performance and reducing startup times.

```CMake
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "
  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
  " COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)

# Install the AOT library on non-Debug builds only.
install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
  CONFIGURATIONS Profile;Release
  COMPONENT Runtime)
```

--------------------------------

### Install Flutter Application Assets

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Configures the installation of Flutter application assets. It ensures the asset directory is completely removed and then re-copied on each build to guarantee up-to-date assets in the installed bundle.

```CMake
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "\n  file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")\n  " COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
  DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
```

--------------------------------

### Configure Google Test for Flutter Camera Plugin (CMake)

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows_camera/windows/CMakeLists.txt

This CMake snippet configures unit testing for the Flutter camera plugin using Google Test. It conditionally enables testing, fetches Google Test from a remote URL, and sets specific cache variables to prevent conflicts with parent project settings and disable installation. The snippet then defines a test executable, includes plugin sources directly for testing, links necessary Flutter and Windows libraries, and integrates Google Test for test discovery.

```CMake
# === Tests ===

if (${include_${PROJECT_NAME}_tests})
set(TEST_RUNNER "${PROJECT_NAME}_test")
enable_testing()
# TODO(stuartmorgan): Consider using a single shared, pre-checked-in googletest
# instance rather than downloading for each plugin. This approach makes sense
# for a template, but not for a monorepo with many plugins.
include(FetchContent)
FetchContent_Declare(
  googletest
  URL https://github.com/google/googletest/archive/release-1.11.0.zip
)
# Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
# Disable install commands for gtest so it doesn't end up in the bundle.
set(INSTALL_GTEST OFF CACHE BOOL "Disable installation of googletest" FORCE)

FetchContent_MakeAvailable(googletest)

# The plugin's C API is not very useful for unit testing, so build the sources
# directly into the test binary rather than using the DLL.
add_executable(${TEST_RUNNER}
  test/mocks.h
  test/camera_plugin_test.cpp
  test/camera_test.cpp
  test/capture_controller_test.cpp
  ${PLUGIN_SOURCES}
)
apply_standard_settings(${TEST_RUNNER})
target_include_directories(${TEST_RUNNER} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}")
target_link_libraries(${TEST_RUNNER} PRIVATE flutter_wrapper_plugin)
target_link_libraries(${TEST_RUNNER} PRIVATE mf mfplat mfuuid d3d11)
target_link_libraries(${TEST_RUNNER} PRIVATE gtest_main gmock)

# flutter_wrapper_plugin has link dependencies on the Flutter DLL.
add_custom_command(TARGET ${TEST_RUNNER} POST_BUILD
  COMMAND ${CMAKE_COMMAND} -E copy_if_different
  "${FLUTTER_LIBRARY}" $<TARGET_FILE_DIR:${TEST_RUNNER}>
)

include(GoogleTest)
gtest_discover_tests(${TEST_RUNNER})
endif()
```

--------------------------------

### Install AOT Library Conditionally with CMake

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

This CMake snippet ensures that the Ahead-Of-Time (AOT) compiled library is installed only when the build type is not 'Debug'. It uses the 'install' command to place the library file in the specified bundle library directory. This practice helps optimize release builds by including necessary runtime components while excluding them from debug builds.

```CMake
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
  install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endif()
```

--------------------------------

### Camera Plugin Access Permission Error Codes

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/camera/README.md

Lists common error codes thrown when initializing the camera controller due to permission issues, including denials and restrictions for camera and audio access on iOS and Android. These errors provide specific context for handling user permissions and guiding users to system settings when necessary.

```APIDOC
CameraAccessDenied: Thrown when user denies the camera access permission.

CameraAccessDeniedWithoutPrompt: iOS only for now. Thrown when user has previously denied the permission. iOS does not allow prompting alert dialog a second time. Users will have to go to Settings > Privacy > Camera in order to enable camera access.

CameraAccessRestricted: iOS only for now. Thrown when camera access is restricted and users cannot grant permission (parental control).

AudioAccessDenied: Thrown when user denies the audio access permission.

AudioAccessDeniedWithoutPrompt: iOS only for now. Thrown when user has previously denied the permission. iOS does not allow prompting alert dialog a second time. Users will have to go to Settings > Privacy > Microphone in order to enable audio access.

AudioAccessRestricted: iOS only for now. Thrown when audio access is restricted and users cannot grant permission (parental control).
```

--------------------------------

### Configure Runtime Path (RPATH) for Flutter Plugin Target

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/linux/CMakeLists.txt

This snippet sets the `INSTALL_RPATH` and `BUILD_RPATH` properties for the plugin target to `$ORIGIN`. This ensures that the dynamic linker can find shared libraries relative to the executable's location at both install and build time, improving portability.

```CMake
set_target_properties(${PLUGIN_NAME} PROPERTIES
  INSTALL_RPATH "$ORIGIN"
  BUILD_RPATH "$ORIGIN"
)
```

--------------------------------

### Define Application Executable and Link Dependencies

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Defines the main application executable with its source files, applies the standard build settings, and links necessary libraries such as Flutter and GTK.

```CMake
add_executable(${BINARY_NAME}
  "main.cc"
  "my_application.cc"
  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)

apply_standard_settings(${BINARY_NAME})

target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
```

--------------------------------

### Configure iOS Camera and Microphone Usage Descriptions

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/camera/README.md

Adds NSCameraUsageDescription and NSMicrophoneUsageDescription keys to the iOS Info.plist file, providing user-facing explanations for camera and microphone access. This is a mandatory step for app store submission when using camera and microphone functionalities.

```XML
<key>NSCameraUsageDescription</key>
<string>your usage description here</string>
<key>NSMicrophoneUsageDescription</key>
<string>your usage description here</string>
```

--------------------------------

### Initialize Flutter Web Application via Service Worker

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/web/index.html

This JavaScript snippet demonstrates the standard method for loading and initializing a Flutter web application. It leverages the `_flutter.loader.loadEntrypoint` function to download the `main.dart.js` file, set up the service worker, and then initialize and run the Flutter engine and application upon the window's load event.

```JavaScript
var serviceWorkerVersion = null;
window.addEventListener('load', function (ev) {
  // Download main.dart.js
  _flutter.loader.loadEntrypoint({
    serviceWorker: {
      serviceWorkerVersion: serviceWorkerVersion
    },
    onEntrypointLoaded: function (engineInitializer) {
      engineInitializer.initializeEngine().then(function (appRunner) {
        appRunner.runApp();
      });
    }
  });
});
```

--------------------------------

### Initialize CMake and Define Ephemeral Directory

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Sets the minimum required CMake version, defines the ephemeral build directory, and includes a generated configuration file. This section establishes the foundational paths for the build process.

```CMake
cmake_minimum_required(VERSION 3.14)

set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")

# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
```

--------------------------------

### Flutter MRZ/VIN SDK API Reference

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/README.md

This section provides a detailed API reference for the Flutter MRZ/VIN SDK, outlining key methods, their parameters, descriptions, and return types. It covers initialization, image buffer processing, file processing, and model loading.

```APIDOC
Method: Future<int?> init(String key)
Description: Initializes the OCR SDK with a license key.
Parameters: key: License string
Return Type: Future<int?>

Method: Future<List<List<OcrLine>>?> recognizeBuffer(Uint8List bytes, int width, int height, int stride, int format, int rotation)
Description: Performs OCR on a raw image buffer.
Parameters: bytes: RGBA image buffer 
 width, height: Image dimensions 
 stride: Row bytes 
 format: Pixel format index 
 rotation: 0/90/180/270
Return Type: Future<List<List<OcrLine>>?>

Method: Future<List<List<OcrLine>>?> recognizeFile(String filename)
Description: Performs OCR on an image file.
Parameters: filename: Path to the image file
Return Type: Future<List<List<OcrLine>>?>

Method: Future<int?> loadModel({ModelType modelType = ModelType.mrz})
Description: Loads the OCR model by type (mrz or vin).
Parameters: modelType: Optional, defaults to ModelType.mrz
Return Type: Future<int?>
```

--------------------------------

### Include Flutter Libraries and System Dependencies

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Includes the Flutter managed directory, finds the GTK+-3.0 package using PkgConfig, and defines the application ID as a preprocessor macro for the build.

```CMake
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})

find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)

add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
```

--------------------------------

### Integrate Flutter Tool and Set Output Directory

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Adds a dependency to ensure the Flutter tool's assembly process runs before building the executable and sets the executable's runtime output directory to an intermediate location to prevent running unbundled copies.

```CMake
add_dependencies(${BINARY_NAME} flutter_assemble)

set_target_properties(${BINARY_NAME}
  PROPERTIES
  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)
```

--------------------------------

### Add Camera Windows Plugin Dependency to pubspec.yaml

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows_camera/README.md

Add the camera_windows plugin as a Git dependency in your Flutter project's pubspec.yaml file to include it in your project. This specifies the source URL for the plugin.

```YAML
camera_windows: 
    git:
    url: https://github.com/yushulx/flutter_camera_windows.git
```

--------------------------------

### Configure Flutter Camera Plugin Shared Library (CMake)

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows_camera/windows/CMakeLists.txt

This CMake snippet defines the core build process for the Flutter camera plugin's shared library on Windows. It specifies the minimum CMake version, sets the project and plugin names, lists all source files, and configures the shared library with necessary properties, include directories, and links to Flutter and Windows multimedia APIs (mf, mfplat, mfuuid, d3d11).

```CMake
cmake_minimum_required(VERSION 3.14)
set(PROJECT_NAME "camera_windows")
project(${PROJECT_NAME} LANGUAGES CXX)

# This value is used when generating builds using this plugin, so it must
# not be changed
set(PLUGIN_NAME "${PROJECT_NAME}_plugin")

list(APPEND PLUGIN_SOURCES
  "camera_plugin.h"
  "camera_plugin.cpp"
  "camera.h"
  "camera.cpp"
  "capture_controller.h"
  "capture_controller.cpp"
  "capture_controller_listener.h"
  "capture_engine_listener.h"
  "capture_engine_listener.cpp"
  "string_utils.h"
  "string_utils.cpp"
  "capture_device_info.h"
  "capture_device_info.cpp"
  "preview_handler.h"
  "preview_handler.cpp"
  "record_handler.h"
  "record_handler.cpp"
  "photo_handler.h"
  "photo_handler.cpp"
  "texture_handler.h"
  "texture_handler.cpp"
  "com_heap_ptr.h"
)

add_library(${PLUGIN_NAME} SHARED
  "camera_windows.cpp"
  "include/camera_windows/camera_windows.h"
  ${PLUGIN_SOURCES}
)

apply_standard_settings(${PLUGIN_NAME})
set_target_properties(${PLUGIN_NAME} PROPERTIES
  CXX_VISIBILITY_PRESET hidden)
target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
target_include_directories(${PLUGIN_NAME} INTERFACE
  "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_link_libraries(${PLUGIN_NAME} PRIVATE flutter flutter_wrapper_plugin)
target_link_libraries(${PLUGIN_NAME} PRIVATE mf mfplat mfuuid d3d11)

# List of absolute paths to libraries that should be bundled with the plugin
set(camera_windows_bundled_libraries
  ""
  PARENT_SCOPE
)
```

--------------------------------

### Discover System Dependencies using PkgConfig

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/flutter/CMakeLists.txt

Utilizes PkgConfig to locate and verify the presence of essential system libraries: GTK, GLIB, and GIO. These libraries are marked as REQUIRED and imported as targets, making them available for linking within the CMake project.

```CMake
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
```

--------------------------------

### Run Flutter Project on Windows

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/README.md

This command line snippet demonstrates how to run the Flutter project specifically targeting the Windows platform. It's used for development and testing on a Windows machine, ensuring the application builds and runs correctly for the specified desktop environment.

```Shell
flutter run -d windows
```

--------------------------------

### Configure CMake Project and Application Naming

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Sets the minimum required CMake version, defines the project name and languages, and specifies the on-disk binary name and GTK application identifier for the Flutter application.

```CMake
cmake_minimum_required(VERSION 3.10)
project(runner LANGUAGES CXX)

set(BINARY_NAME "mrzscanner")
set(APPLICATION_ID "com.example.mrzscanner")
```

--------------------------------

### Specify C++ Wrapper Source Files

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Organizes and lists the core, plugin, and application-specific C++ source files for the Flutter client wrapper. These lists are later used to build the static wrapper libraries.

```CMake
set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper")

list(APPEND CPP_WRAPPER_SOURCES_CORE
  "core_implementations.cc"
  "standard_codec.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/")
list(APPEND CPP_WRAPPER_SOURCES_PLUGIN
  "plugin_registrar.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/")
list(APPEND CPP_WRAPPER_SOURCES_APP
  "flutter_engine.cc"
  "flutter_view_controller.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/")
```

--------------------------------

### Configure Flutter Windows Application Build with CMake

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/runner/CMakeLists.txt

This CMake script defines the build process for a Flutter Windows application. It sets the minimum CMake version, defines the project, adds the executable with its source files, applies standard build settings, defines preprocessor macros for Flutter versioning, disables conflicting Windows macros, and links necessary libraries and include directories. Finally, it ensures the Flutter tool portions of the build are executed.

```CMake
cmake_minimum_required(VERSION 3.14)
project(runner LANGUAGES CXX)

# Define the application target. To change its name, change BINARY_NAME in the
# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer
# work.
#
# Any new source files that you add to the application should be added here.
add_executable(${BINARY_NAME} WIN32
  "flutter_window.cpp"
  "main.cpp"
  "utils.cpp"
  "win32_window.cpp"
  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
  "Runner.rc"
  "runner.exe.manifest"
)

# Apply the standard set of build settings. This can be removed for applications
# that need different build settings.
apply_standard_settings(${BINARY_NAME})

# Add preprocessor definitions for the build version.
target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"")
target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}")
target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}")
target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}")
target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}")

# Disable Windows macros that collide with C++ standard library functions.
target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX")

# Add dependency libraries and include directories. Add any application-specific
# dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app)
target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib")
target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}")

# Run the Flutter tool portions of the build. This must not be removed.
add_dependencies(${BINARY_NAME} flutter_assemble)
```

--------------------------------

### Build Flutter Wrapper Plugin Static Library

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Creates a static library for Flutter plugins, incorporating core and plugin-specific C++ wrapper sources. It applies standard settings, sets position-independent code, and links against the main Flutter library.

```CMake
add_library(flutter_wrapper_plugin STATIC
  ${CPP_WRAPPER_SOURCES_CORE}
  ${CPP_WRAPPER_SOURCES_PLUGIN}
)
apply_standard_settings(flutter_wrapper_plugin)
set_target_properties(flutter_wrapper_plugin PROPERTIES
  POSITION_INDEPENDENT_CODE ON)
set_target_properties(flutter_wrapper_plugin PROPERTIES
  CXX_VISIBILITY_PRESET hidden)
target_link_libraries(flutter_wrapper_plugin PUBLIC flutter)
target_include_directories(flutter_wrapper_plugin PUBLIC
  "${WRAPPER_ROOT}/include"
)
add_dependencies(flutter_wrapper_plugin flutter_assemble)
```

--------------------------------

### Include Generated Plugin Build Rules

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Includes the CMake file responsible for managing the building and integration of Flutter plugins into the application.

```CMake
include(flutter/generated_plugins.cmake)
```

--------------------------------

### Configure Plugin Include Directories, Compile Options, and Link Libraries

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/windows/CMakeLists.txt

Specifies interface include directories for the plugin, ensuring that headers in the current source directory's 'include' folder are accessible. It sets private compile options, including suppressing warning 4121 and setting warning level 3 without treating warnings as errors. Finally, it links essential libraries such as Flutter core components and Dynamsoft OCR SDK libraries (DynamsoftCorex64, DynamsoftLicensex64, etc.) to the plugin.

```CMake
target_include_directories(${PLUGIN_NAME} INTERFACE
  "${CMAKE_CURRENT_SOURCE_DIR}/include")

target_compile_options(${PLUGIN_NAME} PRIVATE /wd4121 /W3 /WX-)

target_link_libraries(${PLUGIN_NAME} PRIVATE flutter flutter_wrapper_plugin "DynamsoftCorex64" "DynamsoftLicensex64" "DynamsoftCaptureVisionRouterx64" "DynamsoftUtilityx64")
```

--------------------------------

### Build Flutter Wrapper Application Static Library

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Constructs a static library for the Flutter application runner, using core and app-specific C++ wrapper sources. It applies standard settings and links against the primary Flutter library.

```CMake
add_library(flutter_wrapper_app STATIC
  ${CPP_WRAPPER_SOURCES_CORE}
  ${CPP_WRAPPER_SOURCES_APP}
)
apply_standard_settings(flutter_wrapper_app)
target_link_libraries(flutter_wrapper_app PUBLIC flutter)
target_include_directories(flutter_wrapper_app PUBLIC
  "${WRAPPER_ROOT}/include"
)
add_dependencies(flutter_wrapper_app flutter_assemble)
```

--------------------------------

### Initialize CMake Project and Ephemeral Directory

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/flutter/CMakeLists.txt

Sets the minimum required CMake version to 3.10 and defines the EPHEMERAL_DIR variable pointing to the ephemeral build directory. It then includes a generated_config.cmake file from this directory, which provides configuration from the Flutter tool.

```CMake
cmake_minimum_required(VERSION 3.10)

set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")

# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
```

--------------------------------

### Configure Flutter Core Library and Headers

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Defines the path to the Flutter Windows DLL and sets up a list of essential Flutter library header files. These variables are then used to create an INTERFACE library for linking and dependency management.

```CMake
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll")

# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE)

list(APPEND FLUTTER_LIBRARY_HEADERS
  "flutter_export.h"
  "flutter_windows.h"
  "flutter_messenger.h"
  "flutter_plugin_registrar.h"
  "flutter_texture_registrar.h"
)
list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
  "${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib")
add_dependencies(flutter flutter_assemble)
```

--------------------------------

### Initialize Flutter SDK with Dynamsoft License Key

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/README.md

Before using the SDK, initialize it with a valid Dynamsoft Capture Vision license key. This code snippet demonstrates how to set the license key within the initSDK function in example/lib/global.dart.

```Dart
Future<int> initSDK() async {
  int? ret = await detector.init(
      "LICENSE-KEY");
  ...
}
```

--------------------------------

### Include Dynamsoft Capture Vision Bundle in Web HTML

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/README.md

For web deployment, include the Dynamsoft Capture Vision bundle script in your index.html file. This script provides the necessary client-side libraries for the SDK to function.

```HTML
<script src="https://cdn.jsdelivr.net/npm/dynamsoft-capture-vision-bundle@3.0.3001/dist/dcv.bundle.min.js"></script>
```

--------------------------------

### Add Custom Command for Flutter Tool Backend Execution

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/flutter/CMakeLists.txt

Defines a custom CMake command responsible for executing the Flutter tool's backend script (tool_backend.sh). This command generates the Flutter library and header files. A _phony_ output file is used to force this command to run on every build, as the full input/output list from the Flutter tool is not available.

```CMake
add_custom_command(
  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
    ${CMAKE_CURRENT_BINARY_DIR}/_phony_
  COMMAND ${CMAKE_COMMAND} -E env
    ${FLUTTER_TOOL_ENVIRONMENT}
    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
      ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
  VERBATIM
)
```

--------------------------------

### Configure Flutter Tool Backend Custom Commands

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/flutter/CMakeLists.txt

Sets up custom build commands to invoke the Flutter tool backend, ensuring that necessary libraries and source files are generated or updated. A phony output is used to force execution on every build.

```CMake
set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_")
set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE)
add_custom_command(
  OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
    ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN}
    ${CPP_WRAPPER_SOURCES_APP}
    ${PHONY_OUTPUT}
  COMMAND ${CMAKE_COMMAND} -E env
    ${FLUTTER_TOOL_ENVIRONMENT}
    "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat"
      ${FLUTTER_TARGET_PLATFORM} $<CONFIG>
  VERBATIM
)
add_custom_target(flutter_assemble DEPENDS
  "${FLUTTER_LIBRARY}"
  ${FLUTTER_LIBRARY_HEADERS}
  ${CPP_WRAPPER_SOURCES_CORE}
  ${CPP_WRAPPER_SOURCES_PLUGIN}
  ${CPP_WRAPPER_SOURCES_APP}
)
```

--------------------------------

### Define CMake Function for Standard Compilation Settings

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This CMake function, `APPLY_STANDARD_SETTINGS`, applies common compilation features and options to a specified target. It enforces C++17, sets warning levels, enables exception handling, and defines debug-specific macros, promoting consistent build practices across targets.

```CMake
add_definitions(-DUNICODE -D_UNICODE)

# Compilation settings that should be applied to most targets.
#
# Be cautious about adding new options here, as plugins use this function by
# default. In most cases, you should add new options to specific targets instead
# of modifying this function.
function(APPLY_STANDARD_SETTINGS TARGET)
  target_compile_features(${TARGET} PUBLIC cxx_std_17)
  target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100")
  target_compile_options(${TARGET} PRIVATE /EHsc)
  target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0")
  target_compile_definitions(${TARGET} PRIVATE "$<$<CONFIG:Debug>:_DEBUG>")
endfunction()
```

--------------------------------

### Configure Profile Build Flags in CMake

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This snippet sets the linker and compiler flags for the 'Profile' build configuration to mirror those of the 'Release' configuration. This ensures that the Profile build behaves similarly to Release in terms of optimization and linking, providing a consistent performance profile.

```CMake
set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}")
set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}")
```

--------------------------------

### Define APPLY_STANDARD_SETTINGS CMake Function

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Defines a reusable CMake function `APPLY_STANDARD_SETTINGS` that applies standard compilation features (C++14) and options (Wall, Werror, O3 for release, NDEBUG for release) to a specified target.

```CMake
function(APPLY_STANDARD_SETTINGS TARGET)
  target_compile_features(${TARGET} PUBLIC cxx_std_14)
  target_compile_options(${TARGET} PRIVATE -Wall -Werror)
  target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
  target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
```

--------------------------------

### Define Flutter OCR SDK Plugin Library and Sources

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/windows/CMakeLists.txt

Configures the plugin's source files and defines the shared library target. It links to the 'lib' directory, appends C++ source files ('flutter_ocr_sdk_plugin.cpp', 'flutter_ocr_sdk_plugin.h') to PLUGIN_SOURCES, and creates a shared library named 'flutter_ocr_sdk_plugin' including the C API header and collected sources.

```CMake
link_directories("${PROJECT_SOURCE_DIR}/lib/") 

# Any new source files that you add to the plugin should be added here.
list(APPEND PLUGIN_SOURCES
  "flutter_ocr_sdk_plugin.cpp"
  "flutter_ocr_sdk_plugin.h"
)

# Define the plugin library target. Its name must not be changed (see comment
# on PLUGIN_NAME above).
add_library(${PLUGIN_NAME} SHARED
  "include/flutter_ocr_sdk/flutter_ocr_sdk_plugin_c_api.h"
  "flutter_ocr_sdk_plugin_c_api.cpp"
  ${PLUGIN_SOURCES}
)
```

--------------------------------

### Configure iOS Camera and Microphone Usage Descriptions

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/README.md

To ensure proper camera and microphone access on iOS, add these usage descriptions to your Info.plist file. This is required for the app to request necessary permissions from the user.

```XML
<key>NSCameraUsageDescription</key>
<string>Can I use the camera please?</string>
<key>NSMicrophoneUsageDescription</key>
<string>Can I use the mic please?</string>
```

--------------------------------

### Define CMake Project and Binary Name

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This snippet initializes the CMake project named 'mrzscanner' for C++ development and sets the output binary name. It also explicitly opts into modern CMake behaviors to prevent warnings with newer CMake versions, ensuring compatibility and best practices.

```CMake
cmake_minimum_required(VERSION 3.14)
project(mrzscanner LANGUAGES CXX)

# The name of the executable created for the application. Change this to change
# the on-disk name of your application.
set(BINARY_NAME "mrzscanner")

# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake.
cmake_policy(SET CMP0063 NEW)
```

--------------------------------

### Configure Flutter Interface Library and Dependencies

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/flutter/CMakeLists.txt

Defines an INTERFACE library named flutter, which serves as a collection of properties for other targets. It specifies the ephemeral directory for include paths and links against the main Flutter library (FLUTTER_LIBRARY) and the previously discovered system dependencies (GTK, GLIB, GIO). A dependency on the flutter_assemble target is also added.

```CMake
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
  "${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
  PkgConfig::GTK
  PkgConfig::GLIB
  PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
```

--------------------------------

### Integrate Flutter Libraries and Plugins in CMake

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This section integrates the Flutter framework and its generated plugins into the CMake build system. It sets the path to the Flutter managed directory, adds it as a subdirectory, and includes the generated plugin rules, enabling the compilation of Flutter components within the project.

```CMake
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})

# Application build; see runner/CMakeLists.txt.
add_subdirectory("runner")


# Generated plugin build rules, which manage building the plugins and adding
# them to the application.
include(flutter/generated_plugins.cmake)
```

--------------------------------

### Initialize Dynamsoft Capture Vision SDK License in Flutter

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/README.md

This Dart code snippet initializes the Dynamsoft Capture Vision SDK with a provided license key. It checks if the initialization is successful and loads the required model. Users must replace 'LICENSE-KEY' with their actual trial license.

```Dart
Future<int> initSDK() async {
    int? ret = await detector.init("LICENSE-KEY");

    if (ret == 0) isLicenseValid = true;
    return await detector.loadModel(modelType: model) ?? -1;
}
```

--------------------------------

### Define Bundled Libraries for Plugin Distribution

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/windows/CMakeLists.txt

Lists absolute paths to libraries that are intended to be bundled with the plugin during distribution. This includes prebuilt libraries located in the 'bin/' directory within the project source. Commented-out lines indicate potential future inclusions of resource directories like 'Models', 'ParserResources', and 'Templates'.

```CMake
set(flutter_ocr_sdk_bundled_libraries
  "${PROJECT_SOURCE_DIR}/bin/"
  # "${PROJECT_SOURCE_DIR}/../resources/Models"
  # "${PROJECT_SOURCE_DIR}/../resources/ParserResources"
  # "${PROJECT_SOURCE_DIR}/../resources/Templates"
  # "${PROJECT_SOURCE_DIR}/../resources/OverlappingChars.data"
  # "${PROJECT_SOURCE_DIR}/../resources/ConfusableChars.data"
  PARENT_SCOPE
)
```

--------------------------------

### Initialize Flutter OCR SDK CMake Project

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/windows/CMakeLists.txt

Sets the minimum required CMake version (3.14), defines the project name 'flutter_ocr_sdk', and specifies CXX as the primary language. It also sets the plugin name 'flutter_ocr_sdk_plugin', which is critical for build compatibility and should not be altered.

```CMake
cmake_minimum_required(VERSION 3.14)

# Project-level configuration.
set(PROJECT_NAME "flutter_ocr_sdk")
project(${PROJECT_NAME} LANGUAGES CXX)

# This value is used when generating builds using this plugin, so it must
# not be changed
set(PLUGIN_NAME "flutter_ocr_sdk_plugin")
```

--------------------------------

### Declare List of Bundled Libraries for Flutter OCR SDK Plugin

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/linux/CMakeLists.txt

This section initializes a CMake variable `flutter_ocr_sdk_bundled_libraries`. This variable is intended to hold a list of absolute paths to libraries that need to be bundled with the plugin, including prebuilt libraries or those generated by external build processes. Currently, it is set as an empty list.

```CMake
# List of absolute paths to libraries that should be bundled with the plugin.
# This list could contain prebuilt libraries, or libraries created by an
# external build triggered from this build file.
set(flutter_ocr_sdk_bundled_libraries
  ""
  PARENT_SCOPE
)
```

--------------------------------

### Specify Include Paths and Link External Libraries for Flutter Plugin

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/linux/CMakeLists.txt

This section defines the include directories for the plugin, making header files accessible during compilation. It also links necessary external libraries, including `flutter` and several Dynamsoft libraries, as well as `PkgConfig::GTK`, which are crucial dependencies for the plugin's functionality.

```CMake
# Source include directories and library dependencies. Add any plugin-specific
# dependencies here.
target_include_directories(${PLUGIN_NAME} INTERFACE
  "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_link_libraries(${PLUGIN_NAME} PRIVATE flutter "DynamsoftCore" "DynamsoftLicense" "DynamsoftCaptureVisionRouter" "DynamsoftUtility")
target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
```

--------------------------------

### Set CMake Policy and RPATH for Bundled Libraries

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Explicitly opts into modern CMake behaviors to avoid warnings with newer CMake versions and configures the runtime path (`RPATH`) to load bundled libraries from the application's `lib/` directory.

```CMake
cmake_policy(SET CMP0063 NEW)

set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
```

--------------------------------

### Define and Prefix Flutter Library Header List

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/flutter/CMakeLists.txt

Populates the FLUTTER_LIBRARY_HEADERS list with a comprehensive set of Flutter C++ header filenames. Subsequently, the custom list_prepend function is used to add the EPHEMERAL_DIR/flutter_linux/ path as a prefix to each header, forming their full paths.

```CMake
list(APPEND FLUTTER_LIBRARY_HEADERS
  "fl_basic_message_channel.h"
  "fl_binary_codec.h"
  "fl_binary_messenger.h"
  "fl_dart_project.h"
  "fl_engine.h"
  "fl_json_message_codec.h"
  "fl_json_method_codec.h"
  "fl_message_codec.h"
  "fl_method_call.h"
  "fl_method_channel.h"
  "fl_method_codec.h"
  "fl_method_response.h"
  "fl_plugin_registrar.h"
  "fl_plugin_registry.h"
  "fl_standard_message_codec.h"
  "fl_standard_method_codec.h"
  "fl_string_codec.h"
  "fl_value.h"
  "fl_view.h"
  "flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
```

--------------------------------

### Apply Standard Build Settings to Flutter Plugin Target

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/linux/CMakeLists.txt

This command applies a predefined set of standard build settings to the plugin target. These settings are typically configured at the application level and help maintain consistency across the project. Plugins requiring custom build control can choose to remove this line.

```CMake
# Apply a standard set of build settings that are configured in the
# application-level CMakeLists.txt. This can be removed for plugins that want
# full control over build settings.
apply_standard_settings(${PLUGIN_NAME})
```

--------------------------------

### Manage CMake Build Configuration Types

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/windows/CMakeLists.txt

This section defines how CMake handles build configurations (Debug, Profile, Release). It checks if the generator supports multiple configurations and sets appropriate CMAKE_CONFIGURATION_TYPES or CMAKE_BUILD_TYPE variables, ensuring consistent build modes across different environments.

```CMake
get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
if(IS_MULTICONFIG)
  set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release"
    CACHE STRING "" FORCE)
else()
  if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    set(CMAKE_BUILD_TYPE "Debug" CACHE
      STRING "Flutter build mode" FORCE)
    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
      "Debug" "Profile" "Release")
  endif()
endif()
```

--------------------------------

### Configure Root Filesystem for Cross-Building

Source: https://github.com/yushulx/flutter_ocr_sdk/blob/main/example/linux/CMakeLists.txt

Conditionally sets CMake's system root (`CMAKE_SYSROOT`) and modifies `CMAKE_FIND_ROOT_PATH_MODE` variables to correctly locate programs, packages, libraries, and includes during cross-compilation if a target platform sysroot is specified.

```CMake
if(FLUTTER_TARGET_PLATFORM_SYSROOT)
  set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
  set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()
```
Tokens:
Raw