Bluetooth Low Energy

https://github.com/yanshouwang/bluetooth_low_energy
Admin
A Flutter plugin that provides comprehensive Bluetooth Low Energy support, enabling both central and...
Tokens:13,022
Snippets:102
Trust Score:8.6
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Remove setUp method

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

The setUp method has been removed in 6.x.

```Dart
// 5.x
// await centralManager.setUp();
```

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

### Define Installation and Bundling Logic

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/CMakeLists.txt

Configures the installation directory structure and copies necessary assets, libraries, and plugins for the final bundle.

```cmake
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
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()

# Start with a clean build bundle directory every time.
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)

# Copy the native assets provided by the build.dart from all packages.
set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/")
install(DIRECTORY "${NATIVE_ASSETS_DIR}"
   DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
   COMPONENT Runtime)

# Fully re-copy the assets directory on each build to avoid having stale files
# from a previous install.
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.
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
  install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
    COMPONENT Runtime)
endif()
```

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

### Remove setUp method

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

The setUp method is no longer required in 6.x.

```Dart
// 5.x
// await peripheralManager.setUp();
```

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

### Configure and Start Advertising in Dart

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Set up advertisement data including service UUIDs and manufacturer-specific data. Note that device names and manufacturer data support vary by platform.

```dart
import 'dart:io';
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final peripheralManager = PeripheralManager();

// Create advertisement data
final advertisement = Advertisement(
  name: Platform.isWindows ? null : 'MyBLEDevice', // Name not supported on Windows
  serviceUUIDs: [UUID.fromString('180D')], // Advertise Heart Rate Service
  manufacturerSpecificData: Platform.isIOS || Platform.isMacOS
      ? [] // Not supported on Apple platforms for advertising
      : [
          ManufacturerSpecificData(
            id: 0x004C, // Apple company ID
            data: Uint8List.fromList([0x01, 0x02, 0x03]),
          ),
        ],
);

// Start advertising
await peripheralManager.startAdvertising(advertisement);

// Stop advertising when done
await peripheralManager.stopAdvertising();
```

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

### Publish Flutter Library and ICU Data

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Makes the Flutter library path and ICU data file available in the parent CMake scope for use in installation steps. The AOT library path is also set.

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

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

### Get CentralManager state

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Access the state property directly instead of using the asynchronous getState method.

```Dart
// 5.x
// final state = await CentralManager.instance.getState();
// 6.x
final state = centralManager.state;
```

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

### Configure CMake and Dependencies

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy_windows/windows/CMakeLists.txt

Sets the minimum CMake version, project name, and fetches the Microsoft.Windows.CppWinRT NuGet package.

```cmake
cmake_minimum_required(VERSION 3.14)

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

# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake.
cmake_policy(VERSION 3.14...3.25)

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

# NUGET: Microsoft.Windows.CppWinRT
set(CPPWINRT_VERSION "2.0.230706.1")

include(FetchContent)
FetchContent_Declare(nuget
  URL "https://dist.nuget.org/win-x86-commandline/v6.10.0/nuget.exe"
  URL_HASH SHA256=bad75b985cef3b2e52fa6141b207db25bafa8724189a420400fcf2787248bf4e
  DOWNLOAD_NO_EXTRACT true
)

find_program(NUGET nuget)
if (NOT NUGET)
    message("Nuget.exe not found, trying to download or use cached version.")
    FetchContent_MakeAvailable(nuget)
    set(NUGET ${nuget_SOURCE_DIR}/nuget.exe)
endif()

message(STATUS "NuGet found: ${NUGET}")

execute_process(COMMAND
  ${NUGET} install Microsoft.Windows.CppWinRT -Version ${CPPWINRT_VERSION} -OutputDirectory packages
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  RESULT_VARIABLE ret)
if(NOT ret EQUAL 0)
  message(FATAL_ERROR "Failed to install nuget package Microsoft.Windows.CppWinRT.${CPPWINRT_VERSION}")
endif()

set(CPPWINRT ${CMAKE_BINARY_DIR}/packages/Microsoft.Windows.CppWinRT.${CPPWINRT_VERSION}/bin/cppwinrt.exe)
execute_process(COMMAND
  ${CPPWINRT} -input sdk -output include
  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  RESULT_VARIABLE ret)
if(NOT ret EQUAL 0)
  message(FATAL_ERROR "Failed to run cppwinrt.exe")
endif()

include_directories(BEFORE SYSTEM ${CMAKE_BINARY_DIR}/include)
```

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

### Configure Project and Build Settings

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/CMakeLists.txt

Sets the project name, application ID, and defines standard compilation settings for targets.

```cmake
cmake_minimum_required(VERSION 3.13)
project(runner 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 "bluetooth_low_energy_example")
# The unique GTK application identifier for this application. See:
# https://wiki.gnome.org/HowDoI/ChooseApplicationID
set(APPLICATION_ID "dev.zeekr.bluetooth_low_energy")

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

# Load bundled libraries from the lib/ directory relative to the binary.
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")

# Root filesystem for cross-building.
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()

# Define build configuration options.
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()

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

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

### Apply Build Settings and Dependencies

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy_windows/windows/CMakeLists.txt

Configures visibility, compiler features, and links required Flutter libraries.

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

# Symbols are hidden by default to reduce the chance of accidental conflicts
# between plugins. This should not be removed; any symbols that should be
# exported should be explicitly exported with the FLUTTER_PLUGIN_EXPORT macro.
set_target_properties(${PLUGIN_NAME} PROPERTIES
  CXX_VISIBILITY_PRESET hidden)
target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)

# Enable compiler support for coroutines
target_compile_features(${PLUGIN_NAME} PRIVATE cxx_std_20)
target_compile_options(${PLUGIN_NAME} PRIVATE /await)

# 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 flutter_wrapper_plugin)

# 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(bluetooth_low_energy_windows_bundled_libraries
  ""
  PARENT_SCOPE
)
```

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

### Configure Flutter Tool Backend Command

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Sets up a custom command to execute the Flutter tool backend. A phony output file is used to ensure the command runs on every build, as direct input/output tracking is not feasible.

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

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

### Apply Standard Build Settings

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/runner/CMakeLists.txt

Applies a predefined set of standard build settings to the application target. This can be customized or removed if different build configurations are required.

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

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

### Link Libraries and Include Directories

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/runner/CMakeLists.txt

Specifies the libraries and include directories required for the application build. Add any custom application-specific dependencies here.

```cmake
# 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}")
```

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

### Implement BLE Central Role Operations

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Demonstrates a complete workflow for a BLE central, including state management, device discovery, connection, MTU negotiation, and GATT characteristic interaction.

```dart
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

class BLECentral {
  final centralManager = CentralManager();
  final discoveries = <Peripheral, DiscoveredEventArgs>{};

  StreamSubscription? _stateSubscription;
  StreamSubscription? _discoverySubscription;
  StreamSubscription? _connectionSubscription;
  StreamSubscription? _notificationSubscription;

  Future<void> initialize() async {
    _stateSubscription = centralManager.stateChanged.listen((eventArgs) async {
      if (Platform.isAndroid && eventArgs.state == BluetoothLowEnergyState.unauthorized) {
        await centralManager.authorize();
      }
    });

    _discoverySubscription = centralManager.discovered.listen((eventArgs) {
      discoveries[eventArgs.peripheral] = eventArgs;
    });

    _connectionSubscription = centralManager.connectionStateChanged.listen((eventArgs) {
      print('${eventArgs.peripheral.uuid}: ${eventArgs.state}');
    });

    _notificationSubscription = centralManager.characteristicNotified.listen((eventArgs) {
      print('Notification: ${eventArgs.value}');
    });
  }

  Future<void> scanAndConnect() async {
    // Start discovery
    discoveries.clear();
    await centralManager.startDiscovery();

    // Wait for devices
    await Future.delayed(const Duration(seconds: 5));
    await centralManager.stopDiscovery();

    // Connect to first device with a name
    final target = discoveries.values.firstWhere(
      (d) => d.advertisement.name != null,
      orElse: () => throw Exception('No named device found'),
    );

    await centralManager.connect(target.peripheral);

    // Request MTU on Android
    if (Platform.isAndroid) {
      await centralManager.requestMTU(target.peripheral, mtu: 517);
    }

    // Discover GATT
    final services = await centralManager.discoverGATT(target.peripheral);

    // Find a readable characteristic and read it
    for (final service in services) {
      for (final characteristic in service.characteristics) {
        if (characteristic.properties.contains(GATTCharacteristicProperty.read)) {
          final value = await centralManager.readCharacteristic(
            target.peripheral,
            characteristic,
          );
          print('Read ${characteristic.uuid}: $value');
        }

        // Enable notifications if supported
        if (characteristic.properties.contains(GATTCharacteristicProperty.notify)) {
          await centralManager.setCharacteristicNotifyState(
            target.peripheral,
            characteristic,
            state: true,
          );
        }
      }
    }
  }

  void dispose() {
    _stateSubscription?.cancel();
    _discoverySubscription?.cancel();
    _connectionSubscription?.cancel();
    _notificationSubscription?.cancel();
  }
}
```

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

### Initialize PeripheralManager

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Configures the device to act as a BLE peripheral and handles state changes.

```dart
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

// Get the PeripheralManager instance
final peripheralManager = PeripheralManager();

// Listen for state changes
final stateSubscription = peripheralManager.stateChanged.listen((eventArgs) async {
  final state = eventArgs.state;
  print('Peripheral manager state: $state');

  if (Platform.isAndroid && state == BluetoothLowEnergyState.unauthorized) {
    await peripheralManager.authorize();
  }
});

// Check current state
final state = peripheralManager.state;
if (state == BluetoothLowEnergyState.poweredOn) {
  print('Ready to advertise');
}
```

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

### Define C++ Wrapper Plugin Sources

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Lists the C++ source files specific to plugin registration within the wrapper. These are prepended with the wrapper root directory.

```cmake
list(APPEND CPP_WRAPPER_SOURCES_PLUGIN
  "plugin_registrar.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/")
```

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

### Initialize PeripheralManager instance

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Use the constructor instead of the factory instance property in 6.x.

```Dart
// 5.x
// final peripheralManager = PeripheralManager.instance;
// 6.x
final peripheralManager = PeripheralManager();
```

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

### Manage Flutter Dependencies and Build Rules

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/CMakeLists.txt

Includes Flutter-managed directories, system dependencies, and build-time dependencies.

```cmake
# Flutter library and tool build rules.
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})

# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)

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

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

# Only the install-generated bundle's copy of the executable will launch
# correctly, since the resources must in the right relative locations. To avoid
# people trying to run the unbundled copy, put it in a subdirectory instead of
# the default top-level location.
set_target_properties(${BINARY_NAME}
  PROPERTIES
  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)

# Enable the test target.
set(include_bluetooth_low_energy_tests TRUE)

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

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

### Create Static Wrapper Library for Plugins

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Builds a static library for Flutter plugins using core and plugin-specific wrapper sources. It applies standard settings, sets position-independent code, and links against the '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)
```

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

### Initialize CentralManager

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Use the constructor instead of the instance property to initialize the CentralManager.

```Dart
// 5.x
// final centralManager = CentralManager.instance;
// 6.x
final centralManager = CentralManager();
```

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

### Define C++ Wrapper Core Sources

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Lists the core C++ source files for the wrapper. These are prepended with the wrapper root directory.

```cmake
list(APPEND CPP_WRAPPER_SOURCES_CORE
  "core_implementations.cc"
  "standard_codec.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/")
```

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

### Configure Unit Tests

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy_windows/windows/CMakeLists.txt

Conditionally enables testing and fetches Google Test if the project is built with tests enabled.

```cmake
# === Tests ===
# These unit tests can be run from a terminal after building the example, or
# from Visual Studio after opening the generated solution file.

# Only enable test builds when building the example (which sets this variable)
# so that plugin clients aren't building the tests.
if (${include_${PROJECT_NAME}_tests})
set(TEST_RUNNER "${PROJECT_NAME}_test")
enable_testing()

# Add the Google Test dependency.
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)
```

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

### Create Static Wrapper Library for Runner

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Builds a static library for the Flutter runner application using core and app-specific wrapper sources. It links against the 'flutter' library and sets include directories.

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

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

### Set Wrapper Root Directory

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Defines the root directory for the C++ client wrapper sources. This is used to locate wrapper implementation files.

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

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

### Define C++ Wrapper App Sources

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Lists the C++ source files for the Flutter application runner. These are prepended with the wrapper root directory.

```cmake
list(APPEND CPP_WRAPPER_SOURCES_APP
  "flutter_engine.cc"
  "flutter_view_controller.cc"
)
list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/")
```

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

### Configure Flutter Linux GTK Dependencies

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/flutter/CMakeLists.txt

Configures system-level dependencies for Flutter on Linux using PkgConfig to find GTK, GLIB, and GIO. Sets paths for the Flutter library and ICU data file.

```cmake
# System-level dependencies.
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)

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

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

### Define Plugin Library Target

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy_windows/windows/CMakeLists.txt

Lists source files and defines the shared library target for the plugin.

```cmake
# Any new source files that you add to the plugin should be added here.
list(APPEND PLUGIN_SOURCES
  "bluetooth_low_energy_windows_plugin.h"
  "bluetooth_low_energy_windows_plugin.cpp"
  "bluetooth_low_energy_api.g.h"
  "bluetooth_low_energy_api.g.cpp"
  "bluetooth_low_energy_exception.h"
  "bluetooth_low_energy_exception.cpp"
  "bluetooth_low_energy_format.h"
  "bluetooth_low_energy_format.cpp"
  "central_manager_impl.h"
  "central_manager_impl.cpp"
  "peripheral_manager_impl.h"
  "peripheral_manager_impl.cpp"
)

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

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

### Handle Bluetooth State and Permissions

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Monitors Bluetooth availability and manages platform-specific permission requests.

```dart
import 'dart:io';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final centralManager = CentralManager();

// Check current state
switch (centralManager.state) {
  case BluetoothLowEnergyState.unknown:
    print('Bluetooth state is unknown');
    break;
  case BluetoothLowEnergyState.unsupported:
    print('Bluetooth is not supported on this device');
    break;
  case BluetoothLowEnergyState.unauthorized:
    print('Bluetooth permission not granted');
    if (Platform.isAndroid) {
      await centralManager.authorize();
    }
    break;
  case BluetoothLowEnergyState.poweredOff:
    print('Bluetooth is turned off');
    break;
  case BluetoothLowEnergyState.poweredOn:
    print('Bluetooth is ready');
    break;
}

// Open app settings for manual permission configuration
if (Platform.isAndroid || Platform.isIOS) {
  await centralManager.showAppSettings();
}
```

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

### Define Flutter Library Headers

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Lists the header files for the Flutter library. These are prepended with the ephemeral directory path.

```cmake
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}/")
```

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

### Manage Central BLE Operations

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Initialize the CentralManager to handle Bluetooth state, scan for peripherals, and manage discovery subscriptions.

```dart
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

// Get the CentralManager instance
final centralManager = CentralManager();

// Listen for state changes and authorize on Android
final stateSubscription = centralManager.stateChanged.listen((eventArgs) async {
  final state = eventArgs.state;
  print('Bluetooth state: $state');

  if (Platform.isAndroid && state == BluetoothLowEnergyState.unauthorized) {
    await centralManager.authorize();
  }
});

// Listen for discovered peripherals
final discoveredSubscription = centralManager.discovered.listen((eventArgs) {
  final peripheral = eventArgs.peripheral;
  final rssi = eventArgs.rssi;
  final advertisement = eventArgs.advertisement;
  print('Discovered: ${advertisement.name ?? peripheral.uuid}, RSSI: $rssi');
});

// Start scanning for peripherals (optionally filter by service UUIDs)
await centralManager.startDiscovery(
  serviceUUIDs: [UUID.fromString('180D')], // Heart Rate Service
);

// Stop scanning
await centralManager.stopDiscovery();
```

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

### Respond to Write Request

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Handles a write request from a central device, responding after processing the request.

```Dart
final central = eventArgs.central;
final characteristic = eventArgs.characteristic;
final request = eventArgs.request;
final offset = request.offset;
final value = request.value;
await peripheralManager.respondWriteRequest(request);
```

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

### Include Generated Configuration

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Includes a generated CMake configuration file. This file is typically created by the Flutter tool and contains project-specific settings.

```cmake
include(${EPHEMERAL_DIR}/generated_config.cmake)
```

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

### Configure Test Executable and Dependencies in CMake

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy_windows/windows/CMakeLists.txt

Defines the test runner executable, sets compiler features for coroutines, and links required libraries for unit testing.

```cmake
add_executable(${TEST_RUNNER}
  test/bluetooth_low_energy_windows_plugin_test.cpp
  ${PLUGIN_SOURCES}
)
apply_standard_settings(${TEST_RUNNER})

# Enable compiler support for coroutines
target_compile_features(${TEST_RUNNER} PRIVATE cxx_std_20)
target_compile_options(${TEST_RUNNER} PRIVATE /await)

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

# Enable automatic test discovery.
include(GoogleTest)
gtest_discover_tests(${TEST_RUNNER})
endif()
```

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

### Define List Prepend Function in CMake

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/flutter/CMakeLists.txt

Defines a CMake function to prepend a prefix to each element in a list. This is a workaround for older CMake versions (pre-3.10) that 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()
```

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

### Configure Flutter Runner Executable

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/runner/CMakeLists.txt

Defines the application executable, links dependencies, and sets include directories for a Flutter project.

```cmake
cmake_minimum_required(VERSION 3.13)
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}
  "main.cc"
  "my_application.cc"
  "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)

# 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 application ID.
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")

# Add dependency libraries. Add any application-specific dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)

target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}")
```

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

### Manage Characteristic Notifications

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Shows how to subscribe to value changes and toggle notification states for a characteristic.

```dart
import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final centralManager = CentralManager();
Peripheral peripheral; // Connected peripheral
GATTCharacteristic characteristic; // Discovered characteristic with notify property

// Listen for characteristic notifications
final notificationSubscription = centralManager.characteristicNotified.listen((eventArgs) {
  if (eventArgs.characteristic == characteristic) {
    final value = eventArgs.value;
    print('Notification received: $value');
  }
});

// Enable notifications
await centralManager.setCharacteristicNotifyState(
  peripheral,
  characteristic,
  state: true,
);

// Disable notifications when done
await centralManager.setCharacteristicNotifyState(
  peripheral,
  characteristic,
  state: false,
);

// Clean up
notificationSubscription.cancel();
```

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

### Discover GATT Services

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Retrieve and iterate through GATT services, characteristics, and descriptors on a connected peripheral.

```dart
import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final centralManager = CentralManager();
Peripheral peripheral; // Connected peripheral

// Discover all GATT services
final services = await centralManager.discoverGATT(peripheral);

for (final service in services) {
  print('Service: ${service.uuid}, Primary: ${service.isPrimary}');

  for (final characteristic in service.characteristics) {
    print('  Characteristic: ${characteristic.uuid}');
    print('  Properties: ${characteristic.properties}');

    for (final descriptor in characteristic.descriptors) {
      print('    Descriptor: ${descriptor.uuid}');
    }
  }
}
```

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

### Connect to BLE Peripherals

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Establish connections to discovered devices and manage connection states. MTU requests are supported specifically for Android to optimize throughput.

```dart
import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final centralManager = CentralManager();
Peripheral? targetPeripheral;

// Listen for connection state changes
final connectionSubscription = centralManager.connectionStateChanged.listen((eventArgs) {
  final peripheral = eventArgs.peripheral;
  final state = eventArgs.state;
  print('Peripheral ${peripheral.uuid}: $state');

  if (state == ConnectionState.connected) {
    print('Connected successfully!');
  } else if (state == ConnectionState.disconnected) {
    print('Disconnected');
  }
});

// Connect to a peripheral (obtained from discovery)
await centralManager.connect(targetPeripheral!);

// Request MTU on Android (recommended for better throughput)
if (Platform.isAndroid) {
  final mtu = await centralManager.requestMTU(targetPeripheral!, mtu: 517);
  print('MTU: $mtu');
}

// Disconnect when done
await centralManager.disconnect(targetPeripheral!);
```

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

### Add Flutter Library Interface Target

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/flutter/CMakeLists.txt

Creates an interface library target for Flutter, setting include directories and linking against the Flutter library and system dependencies (GTK, GLIB, GIO).

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

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

### Define Flutter Application Target

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/runner/CMakeLists.txt

Defines the main executable target for the Flutter Windows application. Source files and resources are listed here. Ensure BINARY_NAME is consistent with the top-level CMakeLists.txt for `flutter run` compatibility.

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

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

### Work with UUIDs

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Creates and manipulates Bluetooth UUIDs from strings, short formats, or MAC addresses.

```dart
import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

// Create from standard string format (128-bit)
final uuid128 = UUID.fromString('0000180d-0000-1000-8000-00805f9b34fb');

// Create from short format (16-bit or 32-bit)
final uuid16 = UUID.fromString('180D'); // Heart Rate Service
final uuid32 = UUID.fromString('0000180D');

// Create short UUID directly
final heartRateService = UUID.short(0x180D);
final heartRateMeasurement = UUID.short(0x2A37);

// Create from MAC address
final peripheralUUID = UUID.fromAddress('AA:BB:CC:DD:EE:FF');
final peripheralUUID2 = UUID.fromAddress(0xAABBCCDDEEFF);

// Check if UUID is short format
print('Is short: ${uuid16.isShort}'); // true

// Convert to string
print('UUID: ${uuid16.toString()}'); // 0000180d-0000-1000-8000-00805f9b34fb

// Compare UUIDs
print('Equal: ${uuid16 == heartRateService}'); // true
```

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

### Define Flutter Library Path

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Sets the path to the Flutter Windows DLL. This library is essential for Flutter's runtime on Windows.

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

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

### Create Flutter Interface Library

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Defines an INTERFACE library target named 'flutter'. This is used to manage include directories and link against the Flutter library.

```cmake
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
  "${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib")
add_dependencies(flutter flutter_assemble)
```

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

### Read and Write Characteristics

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Demonstrates reading values and writing data to characteristics, including manual fragmentation for large payloads.

```dart
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final centralManager = CentralManager();
Peripheral peripheral; // Connected peripheral
GATTCharacteristic characteristic; // Discovered characteristic

// Read a characteristic value
final value = await centralManager.readCharacteristic(peripheral, characteristic);
print('Read value: $value');

// Get maximum write length for fragmentation
final writeType = GATTCharacteristicWriteType.withResponse;
final fragmentSize = await centralManager.getMaximumWriteLength(
  peripheral,
  type: writeType,
);

// Write data with automatic fragmentation
final dataToWrite = Uint8List.fromList([0x01, 0x02, 0x03, 0x04, 0x05]);
var start = 0;
while (start < dataToWrite.length) {
  final end = start + fragmentSize;
  final fragment = end < dataToWrite.length
      ? dataToWrite.sublist(start, end)
      : dataToWrite.sublist(start);

  await centralManager.writeCharacteristic(
    peripheral,
    characteristic,
    value: fragment,
    type: writeType,
  );
  start = end;
}

// Write without response (faster, no confirmation)
await centralManager.writeCharacteristic(
  peripheral,
  characteristic,
  value: Uint8List.fromList([0xAA, 0xBB]),
  type: GATTCharacteristicWriteType.withoutResponse,
);
```

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

### Configure Advertisement manufacturer data

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

The manufacturerSpecificData field now accepts a list of ManufacturerSpecificData objects.

```Dart
// 5.x
// final advertisement = Advertisement(
//     manufacturerSpecificData: ManufacturerSpecificData(
//         id: 0x2e19,
//         data: Uint8List.fromList([0x01, 0x02, 0x03]),
//     ),
// );
// 6.x
final advertisement = Advertisement(
    manufacturerSpecificData: [
        ManufacturerSpecificData(
            id: 0x2e19,
            data: Uint8List.fromList([0x01, 0x02, 0x03]),
        ),
    ],
);
```

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

### Add Flutter Build Dependencies

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/runner/CMakeLists.txt

Ensures that the Flutter tool's build artifacts, specifically `flutter_assemble`, are included as a dependency for the application target. This step is crucial and must not be removed.

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

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

### Set Flutter Version Preprocessor Definitions

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/runner/CMakeLists.txt

Adds preprocessor definitions to the build configuration, embedding Flutter version information directly into the compiled code. This allows the application to access version details at runtime.

```cmake
# 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}")
```

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

### Handle Read and Write Requests in Dart

Source: https://context7.com/yanshouwang/bluetooth_low_energy/llms.txt

Listen to characteristicReadRequested and characteristicWriteRequested streams to respond to central device operations. Use respondReadRequestWithValue or respondWriteRequest to acknowledge operations.

```dart
import 'dart:typed_data';

import 'package:bluetooth_low_energy/bluetooth_low_energy.dart';

final peripheralManager = PeripheralManager();

// Store characteristic values
final characteristicValues = <UUID, Uint8List>{};

// Handle read requests
final readSubscription = peripheralManager.characteristicReadRequested.listen((eventArgs) async {
  final central = eventArgs.central;
  final characteristic = eventArgs.characteristic;
  final request = eventArgs.request;
  final offset = request.offset;

  print('Read request from ${central.uuid} for ${characteristic.uuid}');

  // Get the value for this characteristic
  final value = characteristicValues[characteristic.uuid] ?? Uint8List(0);
  final trimmedValue = value.sublist(offset);

  // Respond with the value
  await peripheralManager.respondReadRequestWithValue(
    request,
    value: trimmedValue,
  );

  // Or respond with an error
  // await peripheralManager.respondReadRequestWithError(
  //   request,
  //   error: GATTError.readNotPermitted,
  // );
});

// Handle write requests
final writeSubscription = peripheralManager.characteristicWriteRequested.listen((eventArgs) async {
  final central = eventArgs.central;
  final characteristic = eventArgs.characteristic;
  final request = eventArgs.request;
  final value = request.value;
  final offset = request.offset;

  print('Write request from ${central.uuid}: $value');

  // Store the written value
  characteristicValues[characteristic.uuid] = value;

  // Acknowledge the write
  await peripheralManager.respondWriteRequest(request);

  // Or respond with an error
  // await peripheralManager.respondWriteRequestWithError(
  //   request,
  //   error: GATTError.writeNotPermitted,
  // );
});
```

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

### Handle read and write requests manually

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Listen to request streams and respond using the peripheralManager methods for mutable characteristics.

```Dart
// The read and write requests are no longer responded automatically 
// after 6.x, listen the characteristicReadRequested,
// characteristicWriteRequested, descriptorReadRequested and
// descriptorWriteRequested, then respond the requests.

// 5.x
// final characteristicReadSubscription = PeripheralManager.instance.characteristicRead.listen((eventArgs) async {
// });
// final characteristicWrittenSubscription = PeripheralManager.instance.characteristicWritten.listen((eventArgs) // async {
// });

// 6.x
// These streams are only available when the characteristic is mutable.
final characteristicReadRequestedSubscription = peripheralManager.characteristicReadRequested.listen((eventArgs) async {
    final central = eventArgs.central;
    final characteristic = eventArgs.characteristic;
    final request = eventArgs.request;
    final offset = request.offset;
    final trimmedValue = value.sublist(offset);
    await peripheralManager.respondReadRequestWithValue(
        request,
        value: trimmedValue,
    );
});
final characteristicWriteRequestedSubscription = peripheralManager.characteristicWriteRequested.listen((eventArgs) async {
```

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

### Set Minimum CMake Version

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Specifies the minimum required version of CMake for the project. Ensure your CMake version meets this requirement.

```cmake
cmake_minimum_required(VERSION 3.14)
```

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

### Define Flutter Assemble Custom Target

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/linux/flutter/CMakeLists.txt

Defines a custom command to build the Flutter library and headers using the Flutter tool backend. A phony target is used to ensure the command runs on every build.

```cmake
# _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.
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}
)
```

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

### Add Dependency to pubspec.yaml

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/README.md

Include the plugin in your Flutter project by adding it to the dependencies section of your pubspec.yaml file.

```YAML
dependencies:
  bluetooth_low_energy: ^<latest-version>
```

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

### Define Ephemeral Directory

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/example/windows/flutter/CMakeLists.txt

Sets a variable for the ephemeral build directory, which is used for generated configuration files. This path is relative to the current source directory.

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

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

### Define GATT services and characteristics

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Use GATTService and specific immutable or mutable GATTCharacteristic types to define services.

```Dart
// 5.x
// final service = GattService(
//     uuid: serviceUUID,
//     characteristics: [
//         GattCharacteristic(
//             uuid: characteristicUUID,
//             properties: [
//                 GattCharacteristicProperty.read,
//                 GattCharacteristicProperty.write,
//                 GattCharacteristicProperty.writeWithoutResponse,
//                 GattCharacteristicProperty.notify,
//                 GattCharacteristicProperty.indicate,
//             ],
//             value: characteristicValue,
//             descriptors: [
//                 GattDescriptor(
//                     uuid: descriptorUUID,
//                     value: descriptorValue, 
//                 ),
//             ],
//         ),
//       ],
//     );
// 6.x
final service = GATTService(
    uuid: serviceUUID,
    characteristics: [
        GATTCharacteristic.immutable(
            uuid: immutableCharacteristicUUID,
            value: immutableCharacteristicValue,
            descriptors: [
                GATTDescriptor.immutable(
                    uuid: immutableDescriptorUUID,
                    value: immutableDescriptorValue,
                ),
            ]
        ),
        GATTCharacteristic.mutable(
            uuid: mutableCharacteristicUUID,
            properties: [
                GATTCharacteristicProperty.read,
                GATTCharacteristicProperty.write,
                GATTCharacteristicProperty.writeWithoutResponse,
                GATTCharacteristicProperty.notify,
                GATTCharacteristicProperty.indicate,
            ],
            permissions: [
                GATTCharacteristicPermission.read,
                GATTCharacteristicPermission.write,
            ],
            descriptors: [
                // This is not supported on iOS and macOS.
                GATTDescriptor.mutable(
                    uuid: mutableDescriptorUUID,
                    permissions: [
                        GATTCharacteristicPermission.read,
                        GATTCharacteristicPermission.write,
                        ],
                ),
            ]
        ),
    ],
);
```

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

### Request MTU on Android

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Manually request the MTU after connecting to a peripheral on Android.

```Dart
// The mtu is no longer requested automatically on Android
// after 6.x, call the requestMTU method after connected.
await centralManager.connect(peripheral);
services.value = await centralManager.discoverGATT(peripheral);
if (Platform.isAndroid) {
    await centralManager.requestMTU(
        peripheral,
        mtu: 517,
    );
}
```

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

### Authorize on Android

Source: https://github.com/yanshouwang/bluetooth_low_energy/blob/master/bluetooth_low_energy/doc/migrations/migration-v6.md

Manually call authorize when the state is unauthorized on Android.

```Dart
// The authorize method is no longer called automatically on Android 
// after 6.x, listen the stateChanged stream and call the authorize
// method when the state is unauthorized.
final stateChangedSubscription = centralManager.stateChanged.listen((eventArgs) async {
    final state = eventArgs.state;
    if (Platform.isAndroid && state == BluetoothLowEnergyState.unauthorized) {
        await centralManager.authorize();
    }
    this.state.value = state;
});
```
Tokens:
Raw