- Add new events WIP - CameraChanged

src/libs/Mapbox.Maui/IMapboxView.cs

@@ -80,4 +80,40 @@ public MapTappedEventArgs(MapTappedPosition position)
     {
         Position = position;
     }
+}
+public class CameraChangedEventArgs : EventArgs
+{
+    public CameraChangedEventArgs(CameraOptions options)
+    {
+        Options = options;
+    }
+
+    public CameraOptions Options { get; }
+}
+public class IndicatorAccuracyRadiusChangedEventArgs : EventArgs
+{
+    public IndicatorAccuracyRadiusChangedEventArgs(double radius)
+    {
+        Radius = radius;
+    }
+
+    public double Radius { get; }
+}
+public class IndicatorBearingChangedEventArgs : EventArgs
+{
+    public IndicatorBearingChangedEventArgs(double bearing)
+    {
+        Bearing = bearing;
+    }
+
+    public double Bearing { get; }
+}
+public class IndicatorPositionChangedEventArgs : EventArgs
+{
+    public IndicatorPositionChangedEventArgs(IPosition position)
+    {
+        Position = position;
+    }
+
+    public IPosition Position { get; }
 }

src/libs/Mapbox.Maui/MapboxView.Events.cs

@@ -4,39 +4,91 @@
 
 partial class MapboxView
 {
-    public event EventHandler<MapTappedEventArgs> MapTapped;
-    public event EventHandler<MapTappedEventArgs> MapLongTapped;
-    internal void InvokeMapTapped(MapTappedPosition point)
+    public event EventHandler<CameraChangedEventArgs> CameraChanged;
+    public static readonly BindableProperty CameraChangedCommandProperty = BindableProperty.Create(
+        nameof(CameraChangedCommand),
+        typeof(ICommand),
+        typeof(MapboxView)
+    );
+    public ICommand CameraChangedCommand
     {
-        MapTapped?.Invoke(this, new MapTappedEventArgs(point));
+        get => (ICommand)GetValue(CameraChangedCommandProperty);
+        set => SetValue(CameraChangedCommandProperty, value);
+    }
+    internal void InvokeCameraChanged(CameraOptions options)
+    {
+        CameraChanged?.Invoke(this, new CameraChangedEventArgs(options));
 
-        if (Command?.CanExecute(point) == true)
+        if (CameraChangedCommand?.CanExecute(options) == true)
         {
-            Command.Execute(point);
+            CameraChangedCommand.Execute(options);
         }
     }
-
-    internal void InvokeMapLongTapped(MapTappedPosition position)
+
+    public event EventHandler<IndicatorAccuracyRadiusChangedEventArgs> IndicatorAccuracyRadiusChanged;
+    public static readonly BindableProperty IndicatorAccuracyRadiusChangedCommandProperty = BindableProperty.Create(
+        nameof(IndicatorAccuracyRadiusChangedCommand),
+        typeof(ICommand),
+        typeof(MapboxView)
+    );
+    public ICommand IndicatorAccuracyRadiusChangedCommand
     {
-        MapLongTapped?.Invoke(this, new MapTappedEventArgs(position));
+        get => (ICommand)GetValue(IndicatorAccuracyRadiusChangedCommandProperty);
+        set => SetValue(IndicatorAccuracyRadiusChangedCommandProperty, value);
+    }
+    internal void InvokeIndicatorAccuracyRadiusChanged(double radius)
+    {
+        IndicatorAccuracyRadiusChanged?.Invoke(this, new IndicatorAccuracyRadiusChangedEventArgs(radius));
 
-        if (LongTapCommand?.CanExecute(position) == true)
+        if (IndicatorAccuracyRadiusChangedCommand?.CanExecute(radius) == true)
         {
-            LongTapCommand.Execute(position);
+            IndicatorAccuracyRadiusChangedCommand.Execute(radius);
         }
     }
-
-    public static readonly BindableProperty LongTapCommandProperty = BindableProperty.Create(
-        nameof(LongTapCommand),
+
+    public event EventHandler<IndicatorBearingChangedEventArgs> IndicatorBearingChanged;
+    public static readonly BindableProperty IndicatorBearingChangedCommandProperty = BindableProperty.Create(
+        nameof(IndicatorBearingChangedCommand),
         typeof(ICommand),
         typeof(MapboxView)
     );
-    public ICommand LongTapCommand
+    public ICommand IndicatorBearingChangedCommand
     {
-        get => (ICommand)GetValue(CommandProperty);
-        set => SetValue(CommandProperty, value);
+        get => (ICommand)GetValue(IndicatorBearingChangedCommandProperty);
+        set => SetValue(IndicatorBearingChangedCommandProperty, value);
     }
+    internal void InvokeIndicatorBearingChanged(double bearing)
+    {
+        IndicatorBearingChanged?.Invoke(this, new IndicatorBearingChangedEventArgs(bearing));
+
+        if (IndicatorBearingChangedCommand?.CanExecute(bearing) == true)
+        {
+            IndicatorBearingChangedCommand.Execute(bearing);
+        }
+    }
+
+    public event EventHandler<IndicatorPositionChangedEventArgs> IndicatorPositionChanged;
+    public static readonly BindableProperty IndicatorPositionChangedCommandProperty = BindableProperty.Create(
+        nameof(IndicatorPositionChangedCommand),
+        typeof(ICommand),
+        typeof(MapboxView)
+    );
+    public ICommand IndicatorPositionChangedCommand
+    {
+        get => (ICommand)GetValue(IndicatorPositionChangedCommandProperty);
+        set => SetValue(IndicatorPositionChangedCommandProperty, value);
+    }
+    internal void InvokeIndicatorPositionChanged(IPosition position)
+    {
+        IndicatorPositionChanged?.Invoke(this, new IndicatorPositionChangedEventArgs(position));
 
+        if (IndicatorPositionChangedCommand?.CanExecute(position) == true)
+        {
+            IndicatorPositionChangedCommand.Execute(position);
+        }
+    }
+
+    public event EventHandler<MapTappedEventArgs> MapTapped;
     public static readonly BindableProperty CommandProperty = BindableProperty.Create(
        nameof(Command),
        typeof(ICommand),
@@ -47,6 +99,36 @@ public ICommand Command
         get => (ICommand)GetValue(CommandProperty);
         set => SetValue(CommandProperty, value);
     }
+    internal void InvokeMapTapped(MapTappedPosition point)
+    {
+        MapTapped?.Invoke(this, new MapTappedEventArgs(point));
+
+        if (Command?.CanExecute(point) == true)
+        {
+            Command.Execute(point);
+        }
+    }
+
+    public event EventHandler<MapTappedEventArgs> MapLongTapped;
+    internal void InvokeMapLongTapped(MapTappedPosition position)
+    {
+        MapLongTapped?.Invoke(this, new MapTappedEventArgs(position));
+
+        if (LongTapCommand?.CanExecute(position) == true)
+        {
+            LongTapCommand.Execute(position);
+        }
+    }    
+    public static readonly BindableProperty LongTapCommandProperty = BindableProperty.Create(
+        nameof(LongTapCommand),
+        typeof(ICommand),
+        typeof(MapboxView)
+    );
+    public ICommand LongTapCommand
+    {
+        get => (ICommand)GetValue(LongTapCommandProperty);
+        set => SetValue(LongTapCommandProperty, value);
+    }
 
     public event EventHandler MapReady;
     internal void InvokeMapReady()
@@ -58,7 +140,6 @@ internal void InvokeMapReady()
             MapReadyCommand.Execute(null);
         }
     }
-
     public static readonly BindableProperty MapReadyCommandProperty = BindableProperty.Create(
        nameof(MapReadyCommand),
        typeof(ICommand),
@@ -95,15 +176,6 @@ public ICommand StyleLoadedCommand
     }
 
     public event EventHandler MapLoaded;
-    internal void InvokeMapLoaded()
-    {
-        MapLoaded?.Invoke(this, EventArgs.Empty);
-
-        if (MapLoadedCommand?.CanExecute(null) == true)
-        {
-            MapLoadedCommand.Execute(null);
-        }
-    }
     public static readonly BindableProperty MapLoadedCommandProperty = BindableProperty.Create(
        nameof(MapLoadedCommand),
        typeof(ICommand),
@@ -115,17 +187,17 @@ public ICommand MapLoadedCommand
         get => (ICommand)GetValue(MapLoadedCommandProperty);
         set => SetValue(MapLoadedCommandProperty, value);
     }
-
-    public event EventHandler MapLoadingError;
-    internal void InvokeMapLoadingError()
+    internal void InvokeMapLoaded()
     {
-        MapLoadingError?.Invoke(this, EventArgs.Empty);
+        MapLoaded?.Invoke(this, EventArgs.Empty);
 
-        if (MapLoadingErrorCommand?.CanExecute(null) == true)
+        if (MapLoadedCommand?.CanExecute(null) == true)
         {
-            MapLoadingErrorCommand.Execute(null);
+            MapLoadedCommand.Execute(null);
         }
     }
+
+    public event EventHandler MapLoadingError;
     public static readonly BindableProperty MapLoadingErrorCommandProperty = BindableProperty.Create(
        nameof(MapLoadingErrorCommand),
        typeof(ICommand),
@@ -137,4 +209,13 @@ public ICommand MapLoadingErrorCommand
         get => (ICommand)GetValue(MapLoadingErrorCommandProperty);
         set => SetValue(MapLoadingErrorCommandProperty, value);
     }
+    internal void InvokeMapLoadingError()
+    {
+        MapLoadingError?.Invoke(this, EventArgs.Empty);
+
+        if (MapLoadingErrorCommand?.CanExecute(null) == true)
+        {
+            MapLoadingErrorCommand.Execute(null);
+        }
+    }
 }