How to best load Locations for MapView from Webserver - swift

Question

I have like 2000 locations in a web database which a user should be able to select on a Map. I can ask the web database to give me only a certain number of locations originating from a current location.
To make everything smooth and elegant I would first instantiate MKMapView, start CLLocationManager and wait until I get a didUpdateLocations. Then I would try to get my data from a Database with a completion handler.
Should I
a) get all data at once
b) get the data in little pieces or chunks ?
What it the best way?
func locationManager(manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
self.gotoCurrentLocation()
if let userLocation = manager.location {
GroundHelper.getAllGroundLocations(userLocation) { self.handleWaypoints($0!) }
}
}
private func handleWaypoints(grounds: [Ground]) {
mapView.addAnnotations(grounds)
}
// MARK: - Helper Methods
typealias GPXCompletionHandler = ([Ground]?) -> Void
class func getAllGroundLocations(userlocation: CLLocation, completionHandler: GPXCompletionHandler) {
let priority = DISPATCH_QUEUE_PRIORITY_DEFAULT
dispatch_async(dispatch_get_global_queue(priority, 0), { ()->() in
var results = RestApiManager.sharedInstance.getGPS(userlocation, limit: 50)
// return first 50 results
dispatch_async(dispatch_get_main_queue(), {
var grounds = [Ground]()
for result in results {
let (_,jsonGround) = result
let ground = Ground(json:jsonGround)
grounds.append(ground)
}
completionHandler(grounds)
})
// get the rest
results = RestApiManager.sharedInstance.getGPS(userlocation)
// return them
dispatch_async(dispatch_get_main_queue(), {
var grounds = [Ground]()
for result in results {
let (_,jsonGround) = result
let ground = Ground(json:jsonGround)
grounds.append(ground)
}
completionHandler(grounds)
})
})
}

Answer 1

Getting all data at once is not scalable. You might make it work on a timely manner with 2000 entries, but what if the data set grows? Can you handle 3000? 5000? 10000 annotations?
Getting your data in chunks, returning only entries near the location the map is centered in, and displaying those entries as the user moves around the map makes more sense. However, this approach is very slow, as there is usually a long delay between the user dragging the map and the annotations appearing on screen (network requests are slow in nature).
Thus, the recommended approach for a great user experience is to cache the results locally. You can do this if you have a local database (Core Data, for example) or you could do this with NSCache.
With this approach, you will be hitting the server with new requests as the user moves around the map, but the amount of results returned can be limited to 20, 50 or 100 (something that gets you the highest amounts of data while being very responsive).
Next, you would be rendering all annotations from your cached results on the map, so the number of annotations will grow as the user moves around the map.
The guys from http://realm.io have a pretty nice video that explains this approach: https://www.youtube.com/watch?v=hNDNXECD84c While you do not need to use their mobile database (Realm), you can get the idea of the application architecture and design.

Answer 2

First of all, you should think if 2000 annotations are going to fit at the same time on the MKMapView. Maybe you should try to only recover the locations that fit in the map you are presenting.
After that, in your code, you are adding annotations everytime didUpdateLocations is called. ¿Are you removing the older annotations in any other place?. If the annotations are not changing, and are on the map, you should't be adding them again.
I think that a good approach should be:
1.- First time didUpdateLocations is called: ask your web service for the annotations that fit in a distance equal to two times the area that is showing your map. Save that location as locationOrigin, save that distance as distanceOrigin
2.- Next time didUpdateLocations is called: If the distance moved from current location to locationOrigin is equal to half the distanceOrigin. You should query the web service again, update your 'Origin' variables, and add only the new annotations to the mapView.
3.- If regionWillChange is called (MKMapViewDelegate): the user is zooming, moving the map, or rotating the device.... the simple approach is reloading the annotations as if we were on step 1. A more smart approach is adding a gesture recognizer to detect if the user is zooming in (in that case the annotations don't change), or zooming out or moving (the annotations may change)

Answer 3

Load them in chunks near the current user locations, if user zoom out load another chunk, if user move the map load another chunk and so on. this way your app would scale better if your annotations become more and more like 1M annotations.

Answer 4

I have actually written an app that can place 7000 annotations on an MKMapView with no performance problems... and that's on an iPad 1. You really don't need to worry about the map.
The only limiting factor I can think of is how long the network call would take and whether that will be a problem. In my case, I was pulling addresses out of the contacts database, geocoding them and then storing the lat-longs in core data. Yes geocoding 7000 addresses takes forever, but once you have the lat-longs putting them on the map is easy stuff and the map code can handle it just fine...