How show map annotations when map span will be 0.1?
I want map pins to not show until map span is <= 0.1
struct City: Identifiable {
let id = UUID()
let name: String
let coordinate: CLLocationCoordinate2D
}
struct ContentView: View {
#State private var region = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 51.507222, longitude: -0.1275), span: MKCoordinateSpan(latitudeDelta: 10, longitudeDelta: 10))
let annotations = [
City(name: "London", coordinate: CLLocationCoordinate2D(latitude: 51.507222, longitude: -0.1275)),
City(name: "Paris", coordinate: CLLocationCoordinate2D(latitude: 48.8567, longitude: 2.3508)),
City(name: "Rome", coordinate: CLLocationCoordinate2D(latitude: 41.9, longitude: 12.5)),
City(name: "Washington DC", coordinate: CLLocationCoordinate2D(latitude: 38.895111, longitude: -77.036667))
]
var body: some View {
Map(coordinateRegion: $region, annotationItems: annotations) {
MapPin(coordinate: $0.coordinate)
}
.frame(width: 400, height: 300)
}
}
How can this be done?
You can't with MapPin because it's a type of protocol not View. Instead of it you can use MapAnnotation. Since your region parameter is binding the view, you can check map span and show/hide your annotation like this;
Map(coordinateRegion: $region, annotationItems: annotations) {
MapAnnotation(coordinate: $0.coordinate) {
// Use whatever value instead of 2.5
if region.span.latitudeDelta < 2.5 {
Image(systemName: "mappin")
.resizable()
.frame(width: 18, height: 36)
.foregroundColor(Color.red)
} else {
EmptyView()
}
}
}
.frame(width: 400, height: 300)
Related
I have a map with marks. When you press it, it centers. But when I rotate the map and click on the marker, it returns to its original value. I don't want the map to come back and the degrees stay the same.
I think that this can be solved through the camera, but I do not know how to do it.
I don't want the rotation to happen and the marker to just be centered. And rotation, if necessary, you can click on the compass in the upper right corner.
My code:
import SwiftUI
import MapKit
struct MapScreenView: View {
#StateObject private var vm = LocationsViewModel()
#State private var camera = MKMapCamera(lookingAtCenter: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698), fromDistance: 7500, pitch: 0, heading: 0)
var body: some View {
ZStack {
VStack {
HStack {
ButtonFilterView()
Spacer()
}
Spacer()
}.zIndex(1)
Map(coordinateRegion:
$vm.mapRegion, annotationItems: vm.locations) {
location in
MapAnnotation(coordinate: location.coordinate) {
LocationMapAnnotationView()
.scaleEffect(vm.mapLocation == location ? 1.1 : 0.7)
.offset(y: vm.mapLocation == location ? -11.5 : 0)
.animation(.easeInOut, value: vm.mapLocation == location)
.onTapGesture {
vm.showTappedLocation(location: location)
}
}
}
.onAppear {
MKMapView.appearance().isZoomEnabled = false
MKMapView.appearance().preferredConfiguration = MKStandardMapConfiguration(elevationStyle: .realistic)
MKMapView.appearance().pointOfInterestFilter = .some(MKPointOfInterestFilter.excludingAll)
MKMapView.appearance().isRotateEnabled = true
MKMapView.appearance().isPitchEnabled = true
MKMapView.appearance().isScrollEnabled = false
}
.edgesIgnoringSafeArea(.all)
}
}
}
struct MapScreenView_Previews: PreviewProvider {
static var previews: some View {
MapScreenView()
}
}
import Foundation
import MapKit
import SwiftUI
class LocationsViewModel: ObservableObject {
#Published var locations: [Location] = LocationDataService.locations
#Published var mapLocation: Location {
didSet {
updateMapRegion(location: mapLocation)
}
}
#Published var mapRegion = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698),
span: MKCoordinateSpan(latitudeDelta: 0.1, longitudeDelta: 0.1))
#Published var mapSpan = MKCoordinateSpan(latitudeDelta: 0.04, longitudeDelta: 0.04)
init() {
self.mapLocation = Location(name: "", coordinate: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698))
updateMapRegion(location: Location(name: "", coordinate: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698)))
}
private func updateMapRegion(location: Location) {
withAnimation(.easeInOut) {
mapRegion.center = location.coordinate
}
}
func showTappedLocation(location: Location) {
mapLocation = location
}
}
I think that this can be solved through the camera, but I do not know how to do it.
I'm working with a map kit map and I need to get the current value of the coordinate span model.
So that when you click on the map point, the map itself does not jump.
import SwiftUI
import MapKit
struct MapScreenView: View {
#StateObject private var vm = LocationsViewModel()
var body: some View {
ZStack {
VStack {
HStack {
ButtonFilterView()
Spacer()
}
Spacer()
}.zIndex(1)
Map(coordinateRegion:
$vm.mapRegion, annotationItems: vm.locations) {
location in
MapAnnotation(coordinate: location.coordinate) {
LocationMapAnnotationView()
.scaleEffect(vm.mapLocation == location ? 1.1 : 0.7)
.animation(.easeInOut, value: vm.mapLocation == location)
.onTapGesture {
vm.showTappedLocation(location: location)
}
}
}
.edgesIgnoringSafeArea(.all)
}
}
}
struct MapScreenView_Previews: PreviewProvider {
static var previews: some View {
MapScreenView()
}
}
import Foundation
import MapKit
import SwiftUI
class LocationsViewModel: ObservableObject {
#Published var locations: [Location] = LocationDataService.locations
#Published var mapLocation: Location {
didSet {
updateMapRegion(location: mapLocation)
}
}
#Published var mapRegion = MKCoordinateRegion()
#Published var mapSpan = MKCoordinateSpan(latitudeDelta: 0.04, longitudeDelta: 0.04)
init() {
self.mapLocation = Location(name: "", coordinate: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698))
updateMapRegion(location: Location(name: "", coordinate: CLLocationCoordinate2D(latitude: 55.755864, longitude: 37.617698)))
}
private func updateMapRegion(location: Location) {
withAnimation(.easeInOut) {
mapRegion = MKCoordinateRegion(
center: location.coordinate,
/// here i want get current span value
span: location.name == "" ? MKCoordinateSpan(latitudeDelta: 0.1, longitudeDelta: 0.1) : mapSpan
)
}
}
func showTappedLocation(location: Location) {
mapLocation = location
}
}
When I click on the map pin, it returns to the hard code span.
How can I get current span?
I searched for many solutions, but did not find the right one
SwiftUI Map takes a binding to a MKCoordinateRegion.
In your code you have...
Map(coordinateRegion: $vm.mapRegion, ...
This is a twi way communication between the view model's region and the map view. When the map updates, this region updates. When you update the region, the map updates.
So the current values of your map are help inside that mapRegion.
Looking at the docs for MKCoordinateRegion https://developer.apple.com/documentation/mapkit/mkcoordinateregion/1452293-span
It has a property span which is an MKCoordinateSpan.
So in the view model... this is the current span of the map.
To update your function you could do something like...
private func updateMapRegion(location: Location) {
withAnimation(.easeInOut) {
mapRegion = MKCoordinateRegion(
center: location.coordinate,
/// here i want get current span value
span: mapRegion.span
)
}
}
Having said that, you seem to be creating a whole new region here. I don't know if that's a good idea. You could just update the center of the existing region without creating a whole new one.
private func updateMapRegion(location: Location) {
withAnimation(.easeInOut) {
mapRegion.center = location.coordinate
}
}
ive got a screen with a map as a background, ive disabled zooming by doing UserInteraction: .pan. But i need to allow people to select the zoom level of their map by selecting a value from a picker.
Ive got the code for the picker and map done but I need to find a way to update the map when the zoom level is updated.
Basicly im just wondering how to programmicly change the zoom level of a MapKit map.
The map code:
Map(coordinateRegion: $viewModel.region,
interactionModes: .pan,
showsUserLocation: showsUser,
userTrackingMode: $tracking,
annotationItems: MapLocations,
annotationContent: { location in
MapAnnotation(
coordinate: location.coordinate,
content: {
ZStack{
Circle()
.fill(.blue)
.opacity(0.2)
.frame(width: CGFloat(setWidth), height: CGFloat(setHeight))
.overlay(
RoundedRectangle(cornerRadius: CGFloat(radius))
.stroke(Color.white, lineWidth: 5)
)
.animation(.default)
Circle()
.fill(.red)
.opacity(0.4)
.frame(width: CGFloat(nextWidth), height: CGFloat(nextWidth))
.overlay(
RoundedRectangle(cornerRadius: CGFloat(radius))
.stroke(Color.white, lineWidth: 2)
)
.animation(.default)
}
}
)
}
$viewModel. code (separate file):
final class MapViewModel: NSObject, ObservableObject, CLLocationManagerDelegate {
static let zoomLevel: Double = (UserDefaults.standard.double(forKey: "zoomLevel"))
static let startingLocation = CLLocationCoordinate2D(latitude: 37.33, longitude: -0-121.89)
static let defualtSpan = MKCoordinateSpan(latitudeDelta: zoomLevel, longitudeDelta: zoomLevel)
#Published var region = MKCoordinateRegion(center: startingLocation, span: defualtSpan)
var locationManager: CLLocationManager?
func checkIfLocationServicesIsEnabled() {
if CLLocationManager.locationServicesEnabled() {
locationManager = CLLocationManager()
locationManager!.delegate = self
locationManager?.desiredAccuracy = kCLLocationAccuracyBest
}else{
print("Location is not enabled, please enable")
}
}
private func checkLocationAuthorization() {
guard let locationManager = locationManager else { return }
switch locationManager.authorizationStatus{
case .notDetermined:
locationManager.requestWhenInUseAuthorization()
case .restricted:
print("your location is restricted likely due to parental controls")
case .denied:
print("You have denied this app to use your location, please change it in settings.")
case .authorizedAlways, .authorizedWhenInUse:
region = MKCoordinateRegion(center: locationManager.location!.coordinate, span: MapViewModel.defualtSpan)
#unknown default:
break
}
}
func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
checkLocationAuthorization()
}
}
Picker code(same file as first one):
Picker("title2", selection: $selectedZoom) {
ForEach(zoomLevels, id: \.self) { zoomLevel in
Text(zoomLevel)
}}
.pickerStyle(.segmented)
.frame(width: 300)
.onChange(of: selectedZoom) { _ in
if selectedZoom == "0.01"{
UserDefaults.standard.set(0.01, forKey: "zoomLevel")
UserDefaults.standard.set("0.01", forKey: "zoomName")
UserDefaults.standard.set("0.01 (Normal)", forKey: "zoomDesc")
zoomDescription = "0.01 (Normal)"
print("1")
}
if selectedZoom == "0.02"{
UserDefaults.standard.set(0.02, forKey: "zoomLevel")
UserDefaults.standard.set("0.02", forKey: "zoomName")
UserDefaults.standard.set("0.02 (Zoomed)", forKey: "zoomDesc")
zoomDescription = "0.02 (Zoomed)"
print("2")
}
if selectedZoom == "0.03"{
UserDefaults.standard.set(0.03, forKey: "zoomLevel")
UserDefaults.standard.set("0.03", forKey: "zoomName")
UserDefaults.standard.set("0.03 (Really Zoomed)", forKey: "zoomDesc")
zoomDescription = "0.03 (Really Zoomed)"
print("3")
}
if selectedZoom == "0.04"{
UserDefaults.standard.set(0.04, forKey: "zoomLevel")
UserDefaults.standard.set("0.04", forKey: "zoomName")
UserDefaults.standard.set("0.04 (Normal)", forKey: "zoomDesc")
zoomDescription = "0.04 (Normal)"
print("4")
}
if selectedZoom == "0.05"{
UserDefaults.standard.set(0.05, forKey: "zoomLevel")
UserDefaults.standard.set("0.05", forKey: "zoomName")
UserDefaults.standard.set("0.05 (SUper zoom)", forKey: "zoomDesc")
zoomDescription = "0.05 (SUper zoom)"
print("5")
}
}
Let me know if you need anything else, thanks!
Here is a very simple example of what you could possible do
import SwiftUI
import MapKit
struct ContentView: View {
#StateObject var viewModel = ViewModel()
var body: some View {
VStack {
Map(coordinateRegion: $viewModel.region)
Picker("Zoom", selection: $viewModel.selectedZoom) {
ForEach(viewModel.zoomLevels, id: \.self) { zoomLevel in
Text("\(zoomLevel)")
}}
.pickerStyle(.segmented)
.frame(width: 300)
}
.padding()
}
}
class ViewModel: ObservableObject {
#Published var region: MKCoordinateRegion = .init(center: .init(latitude: 51.5072, longitude: 0.1276), latitudinalMeters: 500, longitudinalMeters: 500)
#Published var selectedZoom: Int = 1 {
didSet {
updateRegion(for: selectedZoom)
}
}
let zoomLevels = [1, 2, 3, 4, 5]
private func updateRegion(for zoom: Int) {
let center = region.center
let distance = getMeters(for: zoom)
region = MKCoordinateRegion(center: center, latitudinalMeters: distance, longitudinalMeters: distance)
}
private func getMeters(for zoom: Int) -> CLLocationDistance {
500 / Double(zoom)
}
}
You code is a bit too confusing to understand but i made a simple example where a stepper is used to update the zoom value of the map.
struct MaptestVIew: View {
#State var region: MKCoordinateRegion = MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: 0, longitude: 0), span: MKCoordinateSpan(latitudeDelta: 10, longitudeDelta: 10))
#State var zoomScale : Double = 1
let baseZoom : Double = 10
var body: some View {
VStack{
Map(coordinateRegion: $region, interactionModes: .pan)
Stepper(value: $zoomScale, in: 1...10) {
Text("Zoom")
}.onChange(of: zoomScale){ newZoom in
region = MKCoordinateRegion(center: region.center, span: MKCoordinateSpan(latitudeDelta: newZoom * baseZoom, longitudeDelta: newZoom * baseZoom))
}
}
}
}
When the stepper changes value the span for the map region is updated. You would probably want to update your MKCoordinateRegion span to make is zoom in/out
Essentially I would like to create a polyline that connects all coordinates together with a dashed line. How can this be done with the following setup in SwiftUI.
The following is how I am currently drawing the MapMarkers on the map, can a polyline be used to connect them?
#State var myAddresses = [Locations]()
struct Place: Identifiable {
let id = UUID()
let name: String
let latitude: Double
let longitude: Double
var coordinate: CLLocationCoordinate2D {
CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
}
}
Map(coordinateRegion: $region, interactionModes: .all, annotationItems: myAddresses) { place in
MapMarker(coordinate: place.coordinate)
}
.frame(width: UIScreen.main.bounds.width - 20, height: 500)
.cornerRadius(10)
When clicking a specific annotation in MapView I wish to add an overlay with info about the annotation.
What i am looking for is being able to update a variable and then call updateUIView() such that the map shows the overlay corresponding to the annotation that was clicked.
You can do it like this:
let places: [Place] = [
.init(name: "One", coordinate: .init(latitude: 56.951924, longitude: 24.125584)),
.init(name: "Two", coordinate: .init(latitude: 56.967520, longitude: 24.105760)),
.init(name: "Five", coordinate: .init(latitude: 56.9539906, longitude: 24.13649290000000))
]
#State var coordinateRegion = MKCoordinateRegion(center: .init(latitude: 54.6872, longitude: 25.2797), latitudinalMeters: 2000000, longitudinalMeters: 2000000)
var body: some View {
Map(coordinateRegion: $coordinateRegion, annotationItems: places) { (place) in
MapAnnotation(coordinate: place.coordinate) {
Button(action: { print(place.name) }, label: {
Text(place.name)
})
}
}
}
The way to achieve this is track the selected item:
#State private var results: [SearchResult] = []
#State private var selectedResult: UUID?
Your items should already be Identifiable, something like this:
struct SearchResult: Identifiable {
let id = UUID()
let mapItem: MKMapItem
}
Then when you iterate through your map annotations you can decide to generate the selected one, or non-selected one:
Map(coordinateRegion: $region, interactionModes: .all, showsUserLocation: true, userTrackingMode: $trackUser, annotationItems: results) { result in
buildAnnotation(result, isSelected: result.id == selectedResult)
}
And when building the annotation, add a tap gesture recognizer to change the selected item, and center the map if desired:
private func buildAnnotation(_ result: SearchResult, isSelected: Bool) -> some MapAnnotationProtocol {
MapAnnotation(coordinate: result.mapItem.placemark.coordinate, anchorPoint: CGPoint(x: 0.5, y: 1.0)) {
MyCustomView(isSelected: isSelected)
.onTapGesture {
withAnimation {
selectedResult = result.id
region.center = result.mapItem.placemark.coordinate
}
}
}
}
The MyCustomView is just a normal SwiftUI View with body and you can pass in whatever parameters you want to use from the item it represents, including whether it's selected or not.