flutter-embedded-linux

RapidJSON provides two primary styles of interaction:

1. DOM API: Loads the entire JSON structure into memory as a tree. Best for when you need to navigate, modify, or access JSON data non-linearly.
2. SAX API: A stream-based parser that triggers events as it encounters JSON elements. It is extremely memory-efficient and fast, ideal for processing large JSON files where you only need specific data points.

Additional specialized APIs include:

• Schema API: Uses JSON Schema to validate JSON during parsing or generation.
• JSON Pointer: Provides a way to easily access and change specific parts of the DOM using path-like syntax.

To build the flutter-drm-eglstream-backend example, use CMake. You must specify the USER_PROJECT_PATH pointing to the example directory during the configuration step.

$ mkdir build
$ cd build
$ cmake -DUSER_PROJECT_PATH=examples/flutter-drm-eglstream-backend ..
$ cmake --build .

To generate user documentation or run the built-in unit tests, follow these steps:

1. Initialize submodules: git submodule update --init (required for googletest).
2. Create a build directory: mkdir build && cd build.
3. Configure with CMake: cmake ...
4. Build:
   • On Linux: make
   • On Windows: Open the solution in the build directory using Visual Studio.

To run tests after building:

• Use make test or ctest.
• For detailed output, use ctest -V.

To install the library system-wide (requires administrative privileges):

• Run make install from the build directory. Once installed, you can use find_package(RapidJSON) in your CMake-based projects.

To run the application, navigate to your build directory and execute the generated client. You must set the LD_LIBRARY_PATH to include the plugin directory and provide the path to the Flutter bundle using the -b flag.

$ cd <path_to_build_embedder>
$ LD_LIBRARY_PATH=./plugins/video_player/ ./flutter-client -b ./bundle/

The repository provides several example applications demonstrating how to use different backends for Flutter on embedded Linux. Depending on your display server or hardware requirements, you can reference these specific implementations:

• Wayland Client: flutter-wayland-client (for running as a Wayland client app).
• DRM with GBM: flutter-drm-gbm-backend (for fullscreen applications using the DRM backend with GBM).
• DRM with EGLStream: flutter-drm-eglstream-backend (for fullscreen applications using the DRM backend with EGLStream).
• X11 Client: flutter-x11-client (for running as an X11 client app).

Before running the app, you need to build the Flutter asset bundle. This involves cloning the official Flutter plugins, building the video_player package bundle, and copying the icudtl.dat file from your Flutter SDK artifacts to the bundle directory.

$ git clone https://github.com/flutter/plugins.git
$ cd plugins/packages/video_player/video_player
$ flutter build bundle --asset-dir=./bundle/data/flutter_assets
$ cp <path_to_flutter_sdk_install>/bin/cache/artifacts/engine/linux-*/icudtl.dat ./bundle/data

To build the test suite and examples provided in the repository, follow these steps:

1. Initialize submodules to fetch dependencies like googletest:

   git submodule update --init

2. Create a build directory inside the rapidjson directory.
3. Run CMake to configure the project:

   cd rapidjson
   mkdir build
   cd build
   cmake ..

4. Compile the project:
   • On Linux: Run make inside the build directory.
   • On Windows: Open the generated solution in the build directory using Visual Studio.

After building, executables for tests and examples will be located in the bin directory. You can run tests using make test or ctest (use ctest -V for detailed output).

git submodule update --init
mkdir build && cd build
cmake ..
make

To build the standalone X11 backend example application, use CMake. You must provide the USER_PROJECT_PATH definition pointing to the specific project directory (in this case, examples/flutter-x11-client) so the build system can locate the Flutter project source.

$ mkdir build
$ cd build
$ cmake -DUSER_PROJECT_PATH=examples/flutter-x11-client ..
$ cmake --build .

To build the flutter-wayland-client example, which demonstrates a standalone application using the Wayland backend, use CMake. You must provide the USER_PROJECT_PATH flag pointing to the example directory so the build system can locate the Flutter project source.

$ mkdir build
$ cd build
$ cmake -DUSER_PROJECT_PATH=examples/flutter-wayland-client ..
$ cmake --build .

To develop Flutter applications for embedded Linux, you need to use a specific set of tools and repositories. The core embedding engine is separate from the Flutter SDK extensions used for building and debugging.

• For building and debugging apps: Use flutter-elinux, which is a non-official extension to the standard Flutter SDK.
• For the embedding engine: flutter-embedded-linux is the core embedder.
• For plugins: Use flutter-elinux-plugins for eLinux-specific functionality.
• For Yocto integration: Use meta-flutter for Yocto recipes.