location_window_camera_example.dart

Go to the documentation of this file.

import 'dart:ffi';
import 'dart:math' as math;
import 'package:meta/meta.dart';
import 'package:navigine_sdk/com/_library_context.dart' as __lib;
import 'package:navigine_sdk/com/_native_base.dart' as __lib;
import 'package:navigine_sdk/com/_weak_map.dart';
import 'package:navigine_sdk/com/builtin_types__conversion.dart';
import 'package:navigine_sdk/com/navigine/idl/animation_type.dart';
import 'package:navigine_sdk/com/navigine/idl/camera.dart';
import 'package:navigine_sdk/com/navigine/idl/camera_callback.dart';
import 'package:navigine_sdk/com/navigine/idl/camera_listener.dart';
import 'package:navigine_sdk/com/navigine/idl/camera_update_reason.dart';
import 'package:navigine_sdk/com/navigine/idl/point.dart';

class LocationWindowCameraExample {
  LocationWindow? _locationWindow;
  CameraListener? _cameraListener;
 
  LocationWindowCameraExample() {
    _demonstrateLocationWindowCameraMethods();
  }

  void _demonstrateLocationWindowCameraMethods() {
    print("=== LocationWindowCamera Methods ===");
 
    _demonstrateCameraProperties();
    _demonstrateGetSetCamera();
    _demonstrateCameraListeners();
    _demonstrateFlyToMethod();
    _demonstrateMoveToMethod();
    _demonstrateZoomProperties();
    _demonstrateCameraScenarios();
  }

  void _demonstrateCameraProperties() {
    print("--- Camera Properties Setup ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_minZoomFactor]
    // Set minimum zoom factor
    _locationWindow!.minZoomFactor = 10.0;
    print("Set minimum zoom factor to 10.0 pixels per meter");
    // [dart_LocationWindow_minZoomFactor]
 
    // [dart_LocationWindow_maxZoomFactor]
    // Set maximum zoom factor
    _locationWindow!.maxZoomFactor = 1000.0;
    print("Set maximum zoom factor to 1000.0 pixels per meter");
    // [dart_LocationWindow_maxZoomFactor]
  }

  void _demonstrateGetSetCamera() {
    print("--- getCamera and setCamera Methods ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_getCamera]
    // Get current camera position
    Camera currentCamera = _locationWindow!.camera;
    print("Current camera position:");
    print("  Point: (${currentCamera.point.x}, ${currentCamera.point.y})");
    print("  Zoom: ${currentCamera.zoom}");
    print("  Rotation: ${currentCamera.rotation}°");
    print("  Tilt: ${currentCamera.tilt}° (0° = straight downward / map from above)");
    // [dart_LocationWindow_getCamera]
 
    // [dart_Camera_constructor]
    // Create camera with constructor
    Point newPoint = Point(100.0, 200.0);
    Camera newCamera = Camera(newPoint, 50.0, 0.0, 0.0);
    print("Created camera with point (${newPoint.x}, ${newPoint.y}), zoom 50.0, rotation 0°, tilt 0°");
    // [dart_Camera_constructor]
 
    // [dart_Camera_access]
    // Access camera properties
    print("Camera properties:");
    print("  Point: (${newCamera.point.x}, ${newCamera.point.y})");
    print("  Zoom: ${newCamera.zoom}");
    print("  Rotation: ${newCamera.rotation}°");
    print("  Tilt: ${newCamera.tilt}°");
    // [dart_Camera_access]
 
    // [dart_LocationWindow_setCamera]
    // Set camera position without animation
    _locationWindow!.camera = newCamera;
    print("Set camera position to (${newPoint.x}, ${newPoint.y}) with zoom 50.0, rotation 0°, tilt 0°");
    // [dart_LocationWindow_setCamera]
 
    // [dart_LocationWindow_setCamera_2]
    // Set camera position with rotation
    Point rotatedPoint = Point(150.0, 250.0);
    Camera rotatedCamera = Camera(rotatedPoint, 75.0, 45.0, 0.0);
    _locationWindow!.camera = rotatedCamera;
    print("Set camera position to (${rotatedPoint.x}, ${rotatedPoint.y}) with zoom 75.0 and rotation 45°");
    // [dart_LocationWindow_setCamera_2]
 
    // Tilt: oblique view toward the horizon (clamped by the engine to a safe range)
    Camera tiltedCamera = Camera(rotatedPoint, 75.0, 45.0, 40.0);
    _locationWindow!.camera = tiltedCamera;
    print("Set camera with tilt ${tiltedCamera.tilt}° for a perspective view");
 
    // Test different camera positions
    List<Camera> testCameras = [
      Camera(Point(0.0, 0.0), 10.0, 0.0, 0.0),    // Overview camera
      Camera(Point(50.0, 75.0), 500.0, 0.0, 0.0), // Detail camera
      Camera(Point(100.0, 150.0), 100.0, 30.0, 0.0), // Angled camera
    ];
 
    for (int i = 0; i < testCameras.length; i++) {
      Camera camera = testCameras[i];
      _locationWindow!.camera = camera;
      print("Test camera $i: Point (${camera.point.x}, ${camera.point.y}), Zoom ${camera.zoom}, Rotation ${camera.rotation}°, Tilt ${camera.tilt}°");
    }
  }

  void _demonstrateCameraListeners() {
    print("--- Camera Listener Methods ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_addCameraListener]
    // Add camera listener
    _cameraListener = CameraListenerImpl();
    _locationWindow!.addCameraListener(_cameraListener!);
    print("Added camera listener");
    // [dart_LocationWindow_addCameraListener]
 
    // [dart_LocationWindow_removeCameraListener]
    // Remove camera listener
    _locationWindow!.removeCameraListener(_cameraListener!);
    _cameraListener = null;
    print("Removed camera listener");
    // [dart_LocationWindow_removeCameraListener]
 
    // Test multiple listeners
    List<CameraListener> listeners = [
      CameraListenerImpl(),
      CameraListenerImpl(),
      CameraListenerImpl(),
    ];
 
    for (int i = 0; i < listeners.length; i++) {
      _locationWindow!.addCameraListener(listeners[i]);
      print("Added camera listener $i");
    }
 
    for (int i = 0; i < listeners.length; i++) {
      _locationWindow!.removeCameraListener(listeners[i]);
      print("Removed camera listener $i");
    }
  }

  void _demonstrateFlyToMethod() {
    print("--- flyTo Method ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_flyTo]
    // Fly to position with smooth animation
    Point targetPoint = Point(150.0, 250.0);
    Camera targetCamera = Camera(targetPoint, 75.0, 45.0, 30.0);
    CameraCallback callback = CameraCallback(
      onMoveFinished: (completed) {
        if (completed) {
          print("Fly to animation completed successfully");
        } else {
          print("Fly to animation was cancelled");
        }
      },
    );
    _locationWindow!.flyTo(targetCamera, 2000, callback);
    print("Started fly to animation to point (${targetPoint.x}, ${targetPoint.y})");
    // [dart_LocationWindow_flyTo]
 
    // [dart_LocationWindow_flyTo_2]
    // Fly to another position with different duration
    Point targetPoint2 = Point(300.0, 400.0);
    Camera targetCamera2 = Camera(targetPoint2, 25.0, 180.0, 0.0);
    CameraCallback callback2 = CameraCallback(
      onMoveFinished: (completed) {
        print("Second fly to animation ${completed ? 'completed' : 'cancelled'}");
      },
    );
    _locationWindow!.flyTo(targetCamera2, 3000, callback2);
    print("Started fly to animation to point (${targetPoint2.x}, ${targetPoint2.y}) with 3 second duration");
    // [dart_LocationWindow_flyTo_2]
 
    // Test fly to with different parameters
    List<Map<String, dynamic>> flyToTests = [
      {"point": Point(50.0, 50.0), "zoom": 100.0, "rotation": 0.0, "duration": 1000},
      {"point": Point(200.0, 300.0), "zoom": 200.0, "rotation": 90.0, "duration": 1500},
      {"point": Point(400.0, 100.0), "zoom": 50.0, "rotation": 270.0, "duration": 2500},
    ];
 
    for (int i = 0; i < flyToTests.length; i++) {
      Map<String, dynamic> test = flyToTests[i];
      Point point = test["point"];
      double zoom = test["zoom"];
      double rotation = test["rotation"];
      int duration = test["duration"];
 
      Camera camera = Camera(point, zoom, rotation, 0.0);
      CameraCallback testCallback = CameraCallback(
        onMoveFinished: (completed) {
          print("Fly to test $i ${completed ? 'completed' : 'cancelled'}");
        },
      );
      _locationWindow!.flyTo(camera, duration, testCallback);
      print("Fly to test $i: Point (${point.x}, ${point.y}), Zoom $zoom, Rotation ${rotation}°, Duration ${duration}ms");
    }
  }

  void _demonstrateMoveToMethod() {
    print("--- moveTo Method ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_moveTo]
    // Move to position with linear animation
    Point targetPoint = Point(200.0, 300.0);
    Camera targetCamera = Camera(targetPoint, 100.0, 90.0, 0.0);
    CameraCallback callback = CameraCallback(
      onMoveFinished: (completed) {
        print("Move to with linear animation ${completed ? 'completed' : 'cancelled'}");
      },
    );
    _locationWindow!.moveTo(targetCamera, 1500, AnimationType.LINEAR, callback);
    print("Started move to with linear animation");
    // [dart_LocationWindow_moveTo]
 
    // [dart_LocationWindow_moveTo_2]
    // Move to position with cubic animation
    CameraCallback callback2 = CameraCallback(
      onMoveFinished: (completed) {
        print("Move to with cubic animation ${completed ? 'completed' : 'cancelled'}");
      },
    );
    _locationWindow!.moveTo(targetCamera, 1500, AnimationType.CUBIC, callback2);
    print("Started move to with cubic animation");
    // [dart_LocationWindow_moveTo_2]
 
    // [dart_LocationWindow_moveTo_3]
    // Move to position with sine animation
    CameraCallback callback3 = CameraCallback(
      onMoveFinished: (completed) {
        print("Move to with sine animation ${completed ? 'completed' : 'cancelled'}");
      },
    );
    _locationWindow!.moveTo(targetCamera, 1500, AnimationType.SINE, callback3);
    print("Started move to with sine animation");
    // [dart_LocationWindow_moveTo_3]
 
    // [dart_LocationWindow_moveTo_4]
    // Move to position without animation
    Point instantPoint = Point(300.0, 400.0);
    Camera instantCamera = Camera(instantPoint, 25.0, 180.0, 0.0);
    CameraCallback instantCallback = CameraCallback(
      onMoveFinished: (completed) {
        print("Instant move to completed");
      },
    );
    _locationWindow!.moveTo(instantCamera, 0, AnimationType.NONE, instantCallback);
    print("Executed instant move to position (${instantPoint.x}, ${instantPoint.y})");
    // [dart_LocationWindow_moveTo_4]
 
    // Test move to with different animation types
    // [dart_AnimationType_enum]
    List<AnimationType> animationTypes = [
      AnimationType.LINEAR,
      AnimationType.CUBIC,
      AnimationType.QUINT,
      AnimationType.SINE,
      AnimationType.NONE,
    ];
    // [dart_AnimationType_enum]
 
    for (int i = 0; i < animationTypes.length; i++) {
      AnimationType animationType = animationTypes[i];
      Point testPoint = Point(100.0 + i * 50.0, 200.0 + i * 50.0);
      Camera testCamera = Camera(testPoint, 50.0 + i * 10.0, i * 30.0, 0.0);
      CameraCallback testCallback = CameraCallback(
        onMoveFinished: (completed) {
          print("Move to test with ${animationType.name} animation ${completed ? 'completed' : 'cancelled'}");
        },
      );
      _locationWindow!.moveTo(testCamera, 1000, animationType, testCallback);
      print("Move to test $i: Animation ${animationType.name}, Point (${testPoint.x}, ${testPoint.y})");
    }
  }

  void _demonstrateZoomProperties() {
    print("--- Zoom Properties ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_getZoomFactor]
    // Get current zoom factor
    double currentZoom = _locationWindow!.zoomFactor;
    print("Current zoom factor: $currentZoom pixels per meter");
    // [dart_LocationWindow_getZoomFactor]
 
    // [dart_LocationWindow_setZoomFactor]
    // Set new zoom factor
    _locationWindow!.zoomFactor = 200.0;
    print("Set zoom factor to 200.0 pixels per meter");
    // [dart_LocationWindow_setZoomFactor]
 
    // [dart_LocationWindow_getMinZoomFactor]
    // Get minimum zoom factor
    double minZoom = _locationWindow!.minZoomFactor;
    print("Minimum zoom factor: $minZoom pixels per meter");
    // [dart_LocationWindow_getMinZoomFactor]
 
    // [dart_LocationWindow_getMaxZoomFactor]
    // Get maximum zoom factor
    double maxZoom = _locationWindow!.maxZoomFactor;
    print("Maximum zoom factor: $maxZoom pixels per meter");
    // [dart_LocationWindow_getMaxZoomFactor]
 
    // Test zoom factor changes
    List<double> zoomLevels = [50.0, 100.0, 150.0, 300.0, 500.0, 800.0];
 
    for (int i = 0; i < zoomLevels.length; i++) {
      double zoom = zoomLevels[i];
      _locationWindow!.zoomFactor = zoom;
      print("Set zoom factor to $zoom pixels per meter");
 
      // Verify the change
      double actualZoom = _locationWindow!.zoomFactor;
      print("Actual zoom factor: $actualZoom pixels per meter");
    }
  }

  void _demonstrateCameraScenarios() {
    print("--- Camera Scenarios ---");
 
    if (_locationWindow == null) {
      print("LocationWindow not available yet");
      return;
    }
 
    // [dart_LocationWindow_camera_scenarios]
    // Create cameras for different scenarios
    Camera overviewCamera = Camera(Point(0.0, 0.0), 10.0, 0.0, 0.0);
    Camera detailCamera = Camera(Point(50.0, 75.0), 500.0, 0.0, 0.0);
    Camera angledCamera = Camera(Point(100.0, 150.0), 100.0, 30.0, 25.0);
 
    print("Created cameras for different scenarios:");
    print("  Overview camera: zoom ${overviewCamera.zoom}");
    print("  Detail camera: zoom ${detailCamera.zoom}");
    print("  Angled camera: rotation ${angledCamera.rotation}°, tilt ${angledCamera.tilt}°");
    // [dart_LocationWindow_camera_scenarios]
 
    // Test scenario transitions
    List<Camera> scenarios = [overviewCamera, detailCamera, angledCamera];
    List<String> scenarioNames = ["Overview", "Detail", "Angled"];
 
    for (int i = 0; i < scenarios.length; i++) {
      Camera scenario = scenarios[i];
      String name = scenarioNames[i];
 
      CameraCallback scenarioCallback = CameraCallback(
        onMoveFinished: (completed) {
          print("Transition to $name scenario ${completed ? 'completed' : 'cancelled'}");
        },
      );
 
      _locationWindow!.moveTo(scenario, 2000, AnimationType.CUBIC, scenarioCallback);
      print("Transitioning to $name scenario");
    }
  }

  void cleanup() {
    if (_cameraListener != null && _locationWindow != null) {
      _locationWindow!.removeCameraListener(_cameraListener!);
      _cameraListener = null;
      print("Camera listener removed");
    }
  }
}

class CameraListenerImpl implements CameraListener {
  // [dart_CameraListener_onCameraPositionChanged]
  @override
  void onCameraPositionChanged(CameraUpdateReason reason, bool finished) {
    String reasonText = reason == CameraUpdateReason.GESTURES ? "user gestures" : "application";
    String statusText = finished ? "finished" : "in progress";
 
    print("Camera position changed: $reasonText, status: $statusText");
 
    if (finished) {
      print("Camera movement completed");
    }
  }
  // [dart_CameraListener_onCameraPositionChanged]
}

class CameraCallbackImpl {
  static CameraCallback create() {
    return CameraCallback(
      // [dart_CameraCallback_onMoveFinished]
      onMoveFinished: (bool completed) {
        if (completed) {
          print("Camera movement completed successfully");
        } else {
          print("Camera movement was cancelled");
        }
      },
      // [dart_CameraCallback_onMoveFinished]
    );
  }
}

class CameraUtils {
  static Camera createCenteredCamera(double x, double y, double zoom) {
    return Camera(Point(x, y), zoom, 0.0, 0.0);
  }

  static Camera createRotatedCamera(double x, double y, double zoom, double rotation) {
    return Camera(Point(x, y), zoom, rotation, 0.0);
  }

  static Camera createTiltedCamera(double x, double y, double zoom, double rotation, double tilt) {
    return Camera(Point(x, y), zoom, rotation, tilt);
  }

  static bool isValidCamera(Camera camera) {
    return camera.zoom > 0 &&
           camera.rotation >= 0 &&
           camera.rotation < 360 &&
           camera.tilt >= 0;
  }

  static Camera createAreaCamera(double centerX, double centerY, double width, double height) {
    // Calculate zoom based on area size
    double zoom = 100.0 / math.max(width, height);
    return Camera(Point(centerX, centerY), zoom, 0.0, 0.0);
  }
}

void main() {
  // Create example instance
  LocationWindowCameraExample example = LocationWindowCameraExample();
 
  // Assume we have LocationWindow
  // LocationWindow locationWindow = getLocationWindow();
  // example._locationWindow = locationWindow;
 
  // Demonstrate methods
  print("=== LocationWindowCamera Examples ===");
 
  // Cleanup
  example.cleanup();
 
  print("Examples ready to use!");
}