feat: handle gestures in flutter

example/integration_test/controller_test.dart

@@ -25,7 +25,7 @@ void main() {
       await tester.pumpWidget(app);
       final ctrl = await ctrlCompleter.future;
       events.clear();
-      await ctrl.moveCamera(
+      ctrl.moveCamera(
         center: const Geographic(lon: 1, lat: 1),
         bearing: 1,
         zoom: 1,
@@ -707,7 +707,7 @@ void main() {
       final app = App(onMapCreated: ctrlCompleter.complete);
       await tester.pumpWidget(app);
       final ctrl = await ctrlCompleter.future;
-      await ctrl.moveCamera(
+      ctrl.moveCamera(
         center: const Geographic(lon: 1, lat: 2),
         bearing: 1,
         zoom: 1,

example/integration_test/map_scalebar_test.dart

@@ -33,7 +33,7 @@ void main() {
       final widths = <double>[];
 
       for (final zoom in zoomLevels) {
-        await ctrl.moveCamera(zoom: zoom);
+        ctrl.moveCamera(zoom: zoom);
         await tester.pumpAndSettle(const Duration(seconds: 2));
 
         final size = tester.getSize(customPaintFinder);

example/lib/controller_page.dart

@@ -31,7 +31,7 @@ class _ControllerPageState extends State<ControllerPage> {
                 OutlinedButton(
                   onPressed: () async {
                     debugPrint('moveCamera start');
-                    await _controller.moveCamera(
+                    _controller.moveCamera(
                       center: const Geographic(lon: 172.4714, lat: -42.4862),
                       zoom: 4,
                       pitch: 0,

example/lib/events_page.dart

@@ -44,25 +44,25 @@ class _EventsPageState extends State<EventsPage> {
   }
 
   String eventToString(MapEvent event) => switch (event) {
-    MapEventMapCreated() => 'map created',
-    MapEventStyleLoaded() => 'style loaded',
+    MapEventMapCreated() => '[Map Created]',
+    MapEventStyleLoaded() => '[Style Loaded]',
     MapEventMoveCamera() =>
-      'move camera: center ${_formatGeographic(event.camera.center)}, '
+      '[Move Camera] center ${_formatGeographic(event.camera.center)}, '
           'zoom ${event.camera.zoom.toStringAsFixed(2)}, '
           'pitch ${event.camera.pitch.toStringAsFixed(2)}, '
           'bearing ${event.camera.bearing.toStringAsFixed(2)}',
     MapEventStartMoveCamera() =>
-      'start move camera, reason: ${event.reason.name}',
+      '[Start Move Camera], reason: ${event.reason.name}',
     MapEventClick() =>
-      'clicked: ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
+      '[Click] ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
     MapEventDoubleClick() =>
-      'double clicked: ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
+      '[Double Click] ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
     MapEventLongClick() =>
-      'long clicked: ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
+      '[Long Click] ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
     MapEventSecondaryClick() =>
-      'secondary clicked: ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
-    MapEventIdle() => 'idle',
-    MapEventCameraIdle() => 'camera idle',
+      '[Secondary Click] ${_formatGeographic(event.point)}, screen: ${_formatOffset(event.screenPoint)}',
+    MapEventIdle() => '[Idle]',
+    MapEventCameraIdle() => '[Camera Idle]',
   };
 
   void _onEvent(MapEvent event) {

maplibre/lib/src/interaction/interaction_handler.dart

@@ -0,0 +1,29 @@
+import 'package:maplibre/maplibre.dart';
+import 'package:maplibre/src/map_state.dart';
+
+/// Base class for gesture handlers.
+abstract class InteractionHandler {
+  /// Creates a gesture handler with the given [controller].
+  const InteractionHandler(this.controller);
+
+  /// Reference to the map controller.
+  final MapLibreMapState controller;
+
+  /// Accessor to the map options.
+  MapOptions get options => controller.options;
+
+  /// Accessor to the current map camera.
+  MapCamera get camera => controller.camera ?? controller.getCamera();
+
+  /// Accessor to the map gestures configuration.
+  MapGestures get gestures => options.gestures;
+
+  /// Emits a [MapEventStartMoveCamera].
+  void emitMoveStartEvent() => controller.widget.onEvent?.call(
+    const MapEventStartMoveCamera(reason: CameraChangeReason.apiGesture),
+  );
+
+  /// Emits a [MapEventCameraIdle].
+  void emitCameraIdleEvent() =>
+      controller.widget.onEvent?.call(const MapEventCameraIdle());
+}

maplibre/lib/src/interaction/keyboard_handler.dart

@@ -0,0 +1,98 @@
+import 'package:flutter/animation.dart';
+import 'package:flutter/services.dart';
+import 'package:maplibre/src/interaction/interaction_handler.dart';
+import 'package:maplibre/src/map_camera_tween.dart';
+import 'package:maplibre/src/map_state.dart';
+
+/// Handles keyboard interactions.
+class KeyboardHandler extends InteractionHandler {
+  /// Creates a keyboard interaction handler with the given [controller].
+  KeyboardHandler(super.controller) {
+    HardwareKeyboard.instance.addHandler(_handleKeyEvent);
+  }
+
+  final _arrowKeys = <PhysicalKeyboardKey>{
+    PhysicalKeyboardKey.arrowUp,
+    PhysicalKeyboardKey.arrowDown,
+    PhysicalKeyboardKey.arrowLeft,
+    PhysicalKeyboardKey.arrowRight,
+  };
+
+  /// [MapLibreMapState.dispose]
+  void dispose() {
+    HardwareKeyboard.instance.removeHandler(_handleKeyEvent);
+  }
+
+  /// Called when the animation status is completed. Returns true if the
+  /// interation is still ongoing.
+  bool onAnimationStatusCompleted() {
+    // restart animation if arrow keys are still pressed
+    return _updateKeyboardAnimation();
+  }
+
+  /// Handles keyboard events. Returns weather the event was handled.
+  bool _handleKeyEvent(KeyEvent event) {
+    // debugPrint('Keyboard event: $event');
+    if (_arrowKeys.contains(event.physicalKey) &&
+        (event is KeyDownEvent || event is KeyUpEvent)) {
+      _updateKeyboardAnimation();
+      return true;
+    }
+    return false;
+  }
+
+  bool _updateKeyboardAnimation() {
+    var direction = Offset.zero;
+    if (HardwareKeyboard.instance.isPhysicalKeyPressed(
+      PhysicalKeyboardKey.arrowUp,
+    )) {
+      direction += const Offset(0, -1);
+    }
+    if (HardwareKeyboard.instance.isPhysicalKeyPressed(
+      PhysicalKeyboardKey.arrowDown,
+    )) {
+      direction += const Offset(0, 1);
+    }
+    if (HardwareKeyboard.instance.isPhysicalKeyPressed(
+      PhysicalKeyboardKey.arrowLeft,
+    )) {
+      direction += const Offset(-1, 0);
+    }
+    if (HardwareKeyboard.instance.isPhysicalKeyPressed(
+      PhysicalKeyboardKey.arrowRight,
+    )) {
+      direction += const Offset(1, 0);
+    }
+    if (direction == Offset.zero) {
+      controller.animation = null;
+      controller.animationController.stop(canceled: false);
+      emitCameraIdleEvent();
+      return false;
+    }
+
+    // normalize direction
+    direction = Offset.fromDirection(direction.direction);
+    final camera = this.camera;
+    if (controller.animation == null) {
+      emitMoveStartEvent();
+    }
+    controller.animation =
+        MapCameraTween(
+          begin: camera,
+          end: camera.copyWith(
+            center: controller.toLngLat(
+              controller.toScreenLocation(camera.center) + direction * 300,
+            ),
+          ),
+        ).animate(
+          CurvedAnimation(
+            parent: controller.animationController,
+            curve: Curves.linear,
+          ),
+        );
+    controller.animationController
+      ..duration = const Duration(seconds: 1)
+      ..forward(from: 0);
+    return true;
+  }
+}