flutter-pi

To run in Release or Profile mode, you must build an AOT snapshot (app.so). This process involves building a kernel snapshot on your dev machine and then using gen_snapshot on a Linux x64 machine (or WSL).

1. Build Kernel Snapshot (Dev Machine): Replace my_app_name and paths as necessary:

   C:\flutter\bin\cache\dart-sdk\bin\dart.exe \
     C:\flutter\bin\cache\dart-sdk\bin\snapshots\frontend_server.dart.snapshot \
     --sdk-root C:\flutter\bin\cache\artifacts\engine\common\flutter_patched_sdk_product \
     --target=flutter \
     --aot \
     --tfa \
     -Ddart.vm.product=true \
     --packages .dart_tool\package_config.json \
     --output-dill build\kernel_snapshot.dill \
     --verbose \
     --depfile build\kernel_snapshot.d \
     package:my_app_name/main.dart

2. Build app.so (Linux x64/WSL): Use the gen_snapshot_linux_x64_release binary. If building for arm64, omit the --sim-use-hardfp flag.

   gen_snapshot_linux_x64_release \
     --deterministic \
     --snapshot_kind=app-aot-elf \
     --elf=build/flutter_assets/app.so \
     --strip \
     --sim-use-hardfp \
     build/kernel_snapshot.dill

3. Deploy: Upload both the asset bundle and app.so to the Raspberry Pi.

To run flutter-pi, you must configure the Raspberry Pi to boot into console mode (to avoid conflicts with X11 or Wayland) and ensure the GPU is properly configured.

1. Boot Mode: Open sudo raspi-config, navigate to System Options -> Boot / Auto Login, and select Console or Console (Autologin).
2. Graphics Driver: On Raspberry Pi 4 with Raspbian Bullseye, enable the Fake KMS driver via Advanced Options -> GL Driver -> GL (Fake KMS).
3. GPU Memory: Set GPU memory to at least 64 (required for omxplayer_video_player) or 16 via Performance Options -> GPU Memory.
4. Permissions: To allow the pi user to access 3D acceleration without using sudo, run:

   usermod -a -G render pi

   Note: Using sudo to launch flutter-pi is an alternative if you prefer not to change user permissions.

After these changes, reboot the device.

sudo raspi-config
# Follow menu steps for Console mode, GL (Fake KMS), and GPU Memory
usermod -a -G render pi

This workflow allows you to develop a Flutter application on an x64 Linux host machine and deploy it to a Raspberry Pi target. It uses a dedicated Flutter SDK instance (flutter-for-pi) to avoid conflicts with your local installation.

Workflow Overview:

1. Setup Host Environment: Clone the specific Flutter version matching your target's engine binaries and download the engine binaries.
2. Create App: Use the local flutter-for-pi binary to create a new project.
3. Compile for AOT:
   • Build the Flutter bundle.
   • Use the Dart SDK to generate a kernel_snapshot.dill.
   • Use the gen_snapshot_linux_x64_release tool to compile the .dill file into a native app.so (AOT ELF).
4. Upload: Use rsync to transfer the flutter_assets to the Raspberry Pi.
5. Run: Use ssh to kill any existing flutter-pi processes and launch the new application in --release mode.

export VERSION=... # set this to the version determined on the Pi, e.g. 1.22.4
export ARM=... # set this to "arm" or "arm64"
export TARGET=... # set this to your Raspberry Pi's hostname
export APPNAME=hello_pi
export TARGETUSER=pi # set this to your username on the raspberry pi

mkdir -p ~/dev
pushd ~/dev
# one-time setup
git clone --branch $VERSION https://github.com/flutter/flutter.git flutter-for-pi
~/dev/flutter-for-pi/bin/flutter precache
git clone --depth 1 https://github.com/ardera/flutter-engine-binaries-for-arm engine-binaries
chmod +x engine-binaries/$ARM/gen_snapshot_linux_x64_release

# create the application
flutter-for-pi/bin/flutter create $APPNAME

# compile the application
cd $APPNAME
../flutter-for-pi/bin/flutter packages get
../flutter-for-pi/bin/flutter build bundle --no-tree-shake-icons --precompiled
../flutter-for-pi/bin/cache/dart-sdk/bin/dart \
  ../flutter-for-pi/bin/cache/dart-sdk/bin/snapshots/frontend_server.dart.snapshot \
  --sdk-root ~/dev/flutter-for-pi/bin/cache/artifacts/engine/common/flutter_patched_sdk_product \
  --target=flutter \
  --aot --tfa -Ddart.vm.product=true \
  --packages .dart_tool/package_config.json --output-dill build/kernel_snapshot.dill --depfile build/kernel_snapshot.d \
  package:$APPNAME/main.dart

../engine-binaries/$ARM/gen_snapshot_linux_x64_release \
  --deterministic --snapshot_kind=app-aot-elf \
  --strip --sim-use-hardfp \
  --elf=build/flutter_assets/app.so build/kernel_snapshot.dill

# upload the application
rsync --recursive ~/dev/$APPNAME/build/flutter_assets/ $TARGETUSER@$TARGET:dev/$APPNAME

# run the application
ssh $TARGETUSER@$TARGET "killall" "flutter-pi"
ssh $TARGETUSER@$TARGET "dev/flutter-pi/build/flutter-pi" "--release" "~/dev/$APPNAME"
popd

To use flutter-pi, you must first prepare your Raspberry Pi by installing necessary system dependencies, configuring user permissions, and building the flutter-pi binary from source.

Prerequisites:

• A Raspberry Pi with a touchscreen.
• A user with sudo privileges.

Steps:

1. Add your user to the render group to allow access to GPU resources.
2. Install required Mesa, DRM, GBM, and font libraries.
3. Install the pre-compiled Flutter engine binaries for ARM.
4. Build flutter-pi using cmake and make.

Note: Pay attention to the ARM architecture output (arm or arm64) and the Flutter version used by the engine binaries, as these are required for the host-side compilation step.

export APPNAME=hello_pi # change this to the name of your application

# one-time setup
sudo usermod -a -G render $USER
sudo apt --yes install libgl1-mesa-dev libgles2-mesa-dev libegl-mesa0 libdrm-dev libgbm-dev
sudo apt --yes install libsystemd-dev libinput-dev libudev-dev libxkbcommon-dev
sudo apt --yes install ttf-mscorefonts-installer fontconfig
sudo fc-cache
if [ `uname -m` == 'armv7l' ]; then export ARM=arm; else export ARM=arm64; fi
mkdir -p ~/dev
pushd ~/dev
git clone --depth 1 https://github.com/ardera/flutter-engine-binaries-for-arm engine-binaries
sudo ./engine-binaries/install.sh
git clone https://github.com/ardera/flutter-pi.git
cd flutter-pi
mkdir build && cd build
cmake ..
make -j`nproc`
# per-application setup
mkdir -p ~/dev/$APPNAME
popd
echo You will need to set ARM to: $ARM