public ResponderIcon AddResponder(ResponderModel responder)
{
var responderIcon = new ResponderIcon(responder);
ResponderList.Add(responderIcon);
return(responderIcon);
}
private void OnResponderRouteCompleted(Route <ResponderModel> route)
{
ResponderModel responder = route.Element;
if (responder.Status == ResponseStatus.Available)
{
int currentPredefinedRouteIndex;
_responderRoutes.TryGetValue(responder.Id, out currentPredefinedRouteIndex);
int nextPredefinedRouteIndex = _predefinedRoutes.Count > currentPredefinedRouteIndex + 1
? currentPredefinedRouteIndex + 1
: 0;
var defaultRoute = _predefinedRoutes.ElementAt(nextPredefinedRouteIndex);
AssignRouteToResponder(responder, defaultRoute);
}
else if (responder.Status == ResponseStatus.EnRoute)
{
// state as busy
responder.Status = ResponseStatus.Busy;
if (responder.IsPriority)
{
}
}
}
protected override void AddResponderToMap(ResponderModel responder)
{
var responderIcon = new ResponderIcon(responder);
_mapItems.Items.Add(responderIcon);
SetMapIconPosition(responderIcon, responder.GeoLocation, new Point(0.5, 0.5));
}
private async void AssignRouteToResponder(ResponderModel responder, RouteModel defaultRoute)
{
if (defaultRoute.RoutePoints.Any())
{
var routeInstance = new Route <ResponderModel>(defaultRoute.RoutePoints.ToArray());
routeInstance.Element = responder;
// calculate route from the actual point to the route start point
Geoposition responderPosition = PushpinManager.GetResponderPosition(responder);
IEnumerable <Geoposition> routeToStartPosition = await RouteManager.CalculateRoute(responderPosition, routeInstance.RoutePositions.First());
if (!routeToStartPosition.Any())
{
// if routes api dont return any points, route directly to the position.
routeToStartPosition = new [] { responderPosition, routeInstance.RoutePositions.First() };
}
routeInstance.AddRouteToStartPoint(routeToStartPosition);
_routeUpdater.AddRoute(routeInstance);
var routeIndex = _predefinedRoutes.IndexOf(defaultRoute);
_responderRoutes[responder.Id] = routeIndex;
}
else
{
System.Diagnostics.Debug.WriteLine("FullRoute has zero elements, route could not be started");
}
}
public async Task <ResponderRequestModel> CreateResponderForPriorityIncident(object sender, IncidentEventArgs e)
{
var request = new ResponderRequestModel(DepartmentType.Ambulance);
var incident = e.Incident;
if (incident != null)
{
var responderModel = new ResponderModel
{
Id = 8,
ResponderDepartment = DepartmentType.Ambulance,
Status = ResponseStatus.Available,
Longitude = Configuration.AmbulanceLongitude,
Latitude = Configuration.AmbulanceLatitude,
RouteId = 2
};
var responderIcon = new ResponderIcon(responderModel);
request.RespondToRequest(responderIcon);
responderIcon.Responder.Request = request;
responderIcon.Responder.Incident = incident;
responderIcon.RouteIndex = 0;
responderIcon.OnPatrolRoute = false;
await UpdateResponderStatus(responderIcon, ResponseStatus.EnRoute);
ResponderList.Add(responderIcon);
}
return(request);
}
public override Geoposition GetResponderPosition(ResponderModel responder)
{
Marker marker = GetMarkerForResponder(responder);
return(marker != null
? CoordinateConverter.ConvertToAbstraction(marker.Position)
: default(Geoposition));
}
public ResponderViewModel(ResponderModel model)
{
Id = model.Id;
ResponderDepartment = model.ResponderDepartment.ToString();
ResponderCode = model.ResponderCode;
Status = model.Status.ToString();
StatusColor = model.StatusColor;
}
private async Task RequestAmbulanceOnIncident()
{
// locate attending incident (can differ from selected)
IncidentModel currentIncident = FormsMap.Incidents?.FirstOrDefault(i => i.Id == CurrentUserStatus.AttendingIncidentId);
if (currentIncident.IsHighPriority)
{
// search or create ambulance responder
var ambulance = new ResponderModel
{
Id = 8,
ResponderDepartment = DepartmentType.Ambulance,
Status = ResponseStatus.EnRoute,
Longitude = Settings.AmbulanceLongitude,
Latitude = Settings.AmbulanceLatitude,
IsPriority = true
};
// add responder to map
this.PushpinManager.RemoveResponder(ambulance);
this.PushpinManager.AddResponders(new List <ResponderModel>()
{
ambulance
});
var fromPosition = new Geoposition()
{
Latitude = ambulance.Latitude,
Longitude = ambulance.Longitude
};
var toPosition = new Geoposition()
{
Latitude = currentIncident.Latitude,
Longitude = currentIncident.Longitude
};
// create route from ambulance to incident
var routeAmbulance = await this.RouteManager.CalculateRoute(fromPosition, toPosition);
if (!routeAmbulance.Any())
{
// map route service fails
routeAmbulance = new[] { fromPosition, toPosition };
}
// start route movement
var route = new Route <ResponderModel>(routeAmbulance.ToArray());
route.Element = ambulance;
route.AddStartPoint(new Geoposition()
{
Latitude = ambulance.Latitude,
Longitude = ambulance.Longitude
});
route.Init();
_routeUpdater.AddRoute(route);
}
}
public override void RemoveResponder(ResponderModel responder)
{
var responderIcon = _mapItems.Items.OfType <ResponderIcon>().FirstOrDefault(icon => icon.Responder.Id == responder.Id);
if (responderIcon != null)
{
_mapItems?.Items?.Remove(responderIcon);
}
}
public ResponderAnnotationView(IMKAnnotation annotation, ResponderModel responder)
: base(annotation, CustomReuseIdentifier)
{
if (responder != null)
{
responder.PropertyChanged += UpdateColor;
}
Responder = responder;
}
public override void RemoveResponder(ResponderModel responder)
{
var responderAnnotation = _nativeMap.Annotations.OfType <ResponderAnnotation>()
.FirstOrDefault(r => r.Responder.Id == responder.Id);
if (responderAnnotation != null)
{
_nativeMap.RemoveAnnotation(responderAnnotation);
}
}
public override Models.Geoposition GetResponderPosition(ResponderModel responder)
{
var itemsControl = _nativeMap.Children.OfType <MapItemsControl>()
.FirstOrDefault();
var responderIcon = itemsControl?.Items.OfType <ResponderIcon>()
.Where(icon => icon.Responder.Id == responder.Id)
.FirstOrDefault();
return(GetIconPosition(responderIcon));
}
public ResponderIcon(ResponderModel responder)
{
InitializeComponent();
Responder = responder;
if (responder.ResponderDepartment == DepartmentType.Responder)
{
ResponderImage.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
StatusColor.Fill = Responder.StatusColor;
ResponderType.Text = Responder.ResponderCode;
}
protected override void AddResponderToMap(ResponderModel responder)
{
var annotation = new ResponderAnnotation(new
CLLocationCoordinate2D
{
Latitude = responder.Latitude,
Longitude = responder.Longitude
},
responder);
_nativeMap.AddAnnotation(annotation);
}
public override Geoposition GetResponderPosition(ResponderModel responder)
{
var responderAnnotation = _nativeMap.Annotations.OfType <ResponderAnnotation>()
.Where(r => r.Responder.Id == responder.Id)
.FirstOrDefault();
if (responderAnnotation == null)
{
System.Diagnostics.Debug.WriteLine("Responder annotation not found!");
return(default(Geoposition));
}
return(CoordinateConverter.ConvertToAbstraction(responderAnnotation.Coordinate));
}
public override void RemoveResponder(ResponderModel responder)
{
responder.PropertyChanged -= updateColor;
if (_responderPushpinMappings.ContainsKey(responder.Id))
{
Marker marker = GetMarkerForResponder(responder);
_responderPushpinMappings.Remove(responder.Id);
if (marker != null)
{
marker.Remove();
}
}
}
protected override void AddResponderToMap(ResponderModel responder)
{
responder.PropertyChanged += updateColor;
var responderIcon = new ResponderIcon(responder);
var markerOptions = responderIcon.MarkerOptions;
markerOptions.SetPosition(new LatLng(responder.Latitude, responder.Longitude));
Marker marker = _nativeMap.AddMarker(responderIcon.MarkerOptions);
_responderPushpinMappings.Add(responder.Id, marker);
}
public ResponderIcon(ResponderModel responder)
: base()
{
Responder = responder;
_inflater = LayoutInflater.From(Xamarin.Forms.Forms.Context);
_responderIconView = _inflater.Inflate(Resource.Layout.responder_icon_content, null);
var responderType = _responderIconView.FindViewById <TextView>(Resource.Id.responder_type);
responderType.Text = Responder.ResponderCode;
GradientDrawable drawable = (GradientDrawable)responderType.Background;
drawable.SetColor(Responder.StatusColor.ToAndroid());
MarkerOptions.SetTitle(Responder.ResponderCode);
MarkerOptions.SetSnippet(Responder.Incident?.Address);
Bitmap icon = _responderIconView.AsBitmap(Xamarin.Forms.Forms.Context, 60, 60);
MarkerOptions.SetIcon(BitmapDescriptorFactory.FromBitmap(icon));
}
public ResponderIcon(ResponderModel responder)
{
InitializeComponent();
if (responder != null)
{
responder.PropertyChanged += UpdateStatus;
}
Responder = responder;
if (responder.ResponderDepartment == DepartmentType.Responder)
{
ResponderImage.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
var color = Responder.StatusColor.ToMediaColor();
StatusColor.Fill = new SolidColorBrush(color);
ResponderType.Text = Responder.ResponderCode;
}
public abstract void RemoveResponder(ResponderModel responder);
public Marker GetMarkerForResponder(ResponderModel responder)
{
return(_responderPushpinMappings.ContainsKey(responder.Id)
? _responderPushpinMappings[responder.Id]
: null);
}
public void LoadResponderData(ResponderModel responder)
{
NameLabel.Text = responder.ResponderCode;
}
public ResponderAnnotation(CLLocationCoordinate2D coordinate, ResponderModel responder)
: base(coordinate)
{
Responder = responder;
}
public abstract Geoposition GetResponderPosition(ResponderModel responder);
protected abstract void AddResponderToMap(ResponderModel responder);
