Remote Devtools for Flutter Bloc

https://github.com/zakaria-525k/bloc_dev_tools
Admin
A Flutter plugin providing remote developer tools for `flutter_bloc` and `Cubit`, enabling...
Tokens:4,752
Snippets:23
Trust Score:3
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Remote Devtools Server Setup

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/README.md

Instructions for installing and running the remote-dev server using npm. This server is used to connect to and debug Flutter bloc applications remotely.

```bash
npm install -g remotedev-server
remotedev --port 8000
```

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

### Installation Rules for Application Bundle (CMake)

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/CMakeLists.txt

Configures the installation process to create a relocatable application bundle. It cleans the build directory, installs the executable, ICU data, Flutter library, bundled plugins, and assets, ensuring they are placed in the correct subdirectories.

```cmake
include(flutter/generated_plugins.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 "
  file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
  " COMPONENT Runtime)

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)

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)
```

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

### CMake Installation Rules

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/CMakeLists.txt

Configures the installation process for the Flutter application. It defines installation directories and uses the `install` command to copy the executable, ICU data, libraries, and assets to the appropriate locations for runtime execution. It also handles conditional installation of the AOT library.

```cmake
set(BUILD_BUNDLE_DIR "$<TARGET_FILE_DIR:${BINARY_NAME}>")
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}")

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()

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(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
  CONFIGURATIONS Profile;Release
  COMPONENT Runtime)
```

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

### CMake: Install AOT Library for Non-Debug Builds

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/CMakeLists.txt

This CMake script conditionally installs the AOT library to the runtime destination component only when the build type is not Debug. It ensures the library is deployed correctly for release configurations.

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

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

### Flutter Bloc Remote Devtools Installation

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/README.md

This snippet shows how to add the bloc_dev_tools library as a dev dependency in your Flutter project's pubspec.yaml file.

```yaml
dev_dependencies:
  bloc_dev_tools: ^1.0.0
```

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

### BlocObserver Configuration for Remote Devtools

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/README.md

Configures the RemoteDevToolsObserver for bloc state management. It connects to a specified port and IP address, allowing remote observation of bloc states and events. Requires WidgetsFlutterBinding.ensureInitialized() and Bloc.observer setup.

```dart
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final observer = RemoteDevToolsObserver(
    portNumber: 8000,
    ipAddress: 'localhost',
  );

  await observer.connect();
  Bloc.observer = observer;

  runApp(const CounterApp());
}
```

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

### Project and Build Configuration (CMake)

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/CMakeLists.txt

Sets up the minimum CMake version, project name, executable name, and application ID. It also configures build policies, library paths, and root filesystem for cross-compiling. This section defines the fundamental aspects of the build process.

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

set(BINARY_NAME "counter")
set(APPLICATION_ID "com.f2fk.counter")

cmake_policy(SET CMP0063 NEW)
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")

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()

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()
```

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

### CMake Build Configuration

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/runner/CMakeLists.txt

Defines the minimum required CMake version, project name, and languages. It also specifies the executable target, source files, and application-specific libraries and include directories.

```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)
```

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

### Linking Dependencies and Executable Definition (CMake)

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/CMakeLists.txt

Defines the main executable target, includes source files, applies standard settings, and links necessary libraries like Flutter and GTK. It also ensures the executable is built with the Flutter assembly target.

```cmake
set(FLUTTER_MANAGED_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}")

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)

add_dependencies(${BINARY_NAME} flutter_assemble)

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

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

### CMake: Configure Flutter Library and Headers

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/flutter/CMakeLists.txt

Sets up the Flutter library, including its DLL and header files, and links them to a target. It also defines the ICU data file and project build directory.

```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)

# TODO: Move the rest of this into files in ephemeral. See
# https://github.com/flutter/flutter/issues/57146.
set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper")

# === Flutter Library ===
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)
```

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

### CMake: Find GTK, GLIB, GIO dependencies

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/flutter/CMakeLists.txt

Finds and checks for the required GTK, GLIB, and GIO libraries using PkgConfig. This ensures that the necessary system-level dependencies are available for the Flutter application.

```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)
```

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

### Include Flutter Libraries and Plugins

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/CMakeLists.txt

Includes subdirectories for Flutter's managed code and the runner application. It also includes generated plugin build rules to integrate plugins into the application.

```cmake
set(FLUTTER_MANAGED_DIR "flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})

add_subdirectory("runner")


include(flutter/generated_plugins.cmake)
```

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

### CMake: Custom Command for Flutter Tool Backend

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/flutter/CMakeLists.txt

Sets up a custom CMake command to execute the Flutter tool backend script. This command is configured to run every time by using a phony output file and handles environment variables and configuration arguments.

```cmake
# === Flutter tool backend ===
# _phony_ is a non-existent file to force this command to run every time,
# since currently there's no way to get a full input/output list from the
# flutter tool.
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"
      windows-x64 $<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}
)
```

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

### CMake: Create Flutter C++ Wrapper Library for Plugins

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/flutter/CMakeLists.txt

Defines a static C++ library for Flutter plugins, including core and plugin-specific wrapper sources. It sets independent code and visibility properties and links against the Flutter library.

```cmake
# Wrapper sources needed for a plugin.
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}/")

# Wrapper sources needed for a plugin.
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)
```

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

### CMake: Add Flutter Library Interface

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/flutter/CMakeLists.txt

Creates an interface library target named 'flutter' and configures its include directories and link libraries. It links against the Flutter library itself and the system dependencies (GTK, GLIB, GIO) found earlier.

```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)
```

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

### CMake: Create Flutter C++ Wrapper Library for Runner Application

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/flutter/CMakeLists.txt

Defines a static C++ library for the Flutter runner application, including core and application-specific wrapper sources. It links against the Flutter library and specifies include directories.

```cmake
# Wrapper sources needed for the runner.
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_APP
  "flutter_engine.cc"
  "flutter_view_controller.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/")

# Wrapper sources needed for the runner.
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)
```

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

### Applying Standard Compilation Settings (CMake)

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/CMakeLists.txt

Defines a CMake function `APPLY_STANDARD_SETTINGS` to apply common compilation features and options to targets. It enables C++14, sets warning flags, and configures optimization levels based on the build type.

```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()
```

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

### Standard Compilation Settings Function

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/CMakeLists.txt

Defines a reusable function `APPLY_STANDARD_SETTINGS` to apply common compilation features, options, and definitions to a given target. This includes setting the C++ standard, warning levels, exception handling, and debug definitions.

```cmake
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()
```

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

### CMake: Custom command for Flutter tool backend

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/flutter/CMakeLists.txt

Defines a custom command to execute the Flutter tool backend script. This command is set up to run whenever the output files (${FLUTTER_LIBRARY}, ${FLUTTER_LIBRARY_HEADERS}) or a phony target are needed. It sets environment variables required by the Flutter tool.

```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
)
add_custom_target(flutter_assemble DEPENDS
  "${FLUTTER_LIBRARY}"
  ${FLUTTER_LIBRARY_HEADERS}
)
```

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

### CMake: Define list_prepend function

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/flutter/CMakeLists.txt

Defines a CMake function `list_prepend` that adds a prefix to each element of a given list. This is used as a workaround for versions of CMake older than 3.10 which lack the `list(TRANSFORM ... PREPEND ...)` command.

```cmake
function(list_prepend LIST_NAME PREFIX)
    set(NEW_LIST "")
    foreach(element ${${LIST_NAME}})
        list(APPEND NEW_LIST "${PREFIX}${element}")
    endforeach(element)
    set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
```

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

### CMake: Configure Flutter Library and Headers

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/linux/flutter/CMakeLists.txt

Sets up the Flutter library path and includes necessary header files. It defines variables for the Flutter library, ICU data file, project build directory, and AOT library, making them available to the parent scope.

```cmake
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")

# 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/lib/libapp.so" PARENT_SCOPE)
```

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

### CMake Project Configuration and Build Modes

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/example/windows/CMakeLists.txt

Configures the CMake project, sets the minimum version, project name, and binary name. It also defines build configuration types (Debug, Profile, Release) based on whether the generator supports multi-configuration builds.

```cmake
cmake_minimum_required(VERSION 3.14)
project(counter LANGUAGES CXX)

set(BINARY_NAME "counter")

cmake_policy(VERSION 3.14...3.25)

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()

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}")

add_definitions(-DUNICODE -D_UNICODE)
```

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

### Mappable Event and State Implementation

Source: https://github.com/zakaria-525k/bloc_dev_tools/blob/main/README.md

Demonstrates how to make Flutter bloc Events and States 'Mappable' by implementing MappableToJson and MappableFromJson. This is necessary for proper serialization and deserialization when using the remote devtools.

```dart
class CounterState extends Equatable implements MappableToJson, MappableFromJson {
  final int counter;

  const CounterState({
    required this.counter,
  });

  CounterState copyWith({
    int? counter,
  }) =>
      CounterState(
        counter: counter ?? this.counter,
      );

  @override
  List<Object> get props => [
    counter,
  ];

  @override
  Map<String, dynamic> toJson() => {
    'counter': counter,
  };

  @override
  CounterState fromJson(Map<String, dynamic> json) {
    return CounterState(counter: json['counter']);
  }
}
```
Tokens:
Raw