             self.request = request
         }
         
+        /// The monitoring mode for this listener
+        var monitoringMode: LocationMonitoring {
+            if request.accuracy.requiresStandardMonitoring {
+                return .Standard
+            }
+
+            if request.updateFrequency.requiresStandardMonitoring {
+                return .Standard
+            }
+
+            return .SignificantUpdates
+        }
+
+        /// The desired accuracy for this listener
+        var desiredAccuracy: CLLocationAccuracy {
+            switch request.accuracy {
+            case .Coarse:
+                return kCLLocationAccuracyKilometer
+            case .Good:
+                return kCLLocationAccuracyHundredMeters
+            case .Better:
+                return kCLLocationAccuracyNearestTenMeters
+            case .Best:
+                return kCLLocationAccuracyBest
+            }
+        }
+
+        /// The distance filter for this listener
+        var distanceFilter: CLLocationDistance {
+            guard request.updateFrequency != .Continuous else {
+                return kCLDistanceFilterNone
+            }
+
+            // NOTE: A distance filter of half the accuracy allows some updates while the device is
+            //       stationary (caused by GPS fluctuations) in an attempt to ensure timely updates
+            //       while the device is moving (so previous inaccuracies can be corrected).
+            switch request.accuracy {
+            case .Best:
+                // Two meters is good for best accuracy, which evaluates to -1.0 but typically generates
+                // updates with an accuracy of ±5m in practice.
+                return 2.0
+            default:
+                return desiredAccuracy / 2
+            }
+        }
+
         func shouldUpdateListenerForLocation(location: CLLocation) -> Bool {
             switch request.updateFrequency {
             case .Continuous:

 There are two kinds of location monitoring in iOS: significant updates and standard location monitoring.
 Significant updates are more power efficient, but have limitations on accuracy and update frequency.
 */
private enum LocationMonitoring {
    /// Monitor for only "significant updates" to the user's location (using cell towers only)
    case SignificantUpdates
    /// Monitor for all updates to the user's location (using GPS, WiFi, etc)
    case Standard
}

private extension LocationAccuracy {

        return manager.coreLocationAuthorizationStatus
    }

    /// The monitoring mode for the current state.
    ///
    /// This takes into account the listeners' monitoring modes and the authorization status.
    private var monitoringMode: LocationMonitoring? {
        guard authorizationStatus.allowsMonitoring else {
            return nil
        }

        guard let value = allLocationListeners.map({ $0.monitoringMode }).maxElement() else {
            return nil
        }

        if authorizationStatus.requiresStandardMonitoring {
            return .Standard
        }

        return value
    }

    /// The desired accuracy for the current state.
    private var desiredAccuracy: CLLocationAccuracy {
        // Note: CLLocationAccuracy is expressed as an allowable amount of error, so we want the "minimum" value.

        guard let value = allLocationListeners.map({ $0.desiredAccuracy }).minElement() else {
            return kCLLocationAccuracyHundredMeters
        }

        return value
    }

    /// The distance filter for the current state.
    private var distanceFilter: CLLocationDistance {
        guard let value = allLocationListeners.map({ $0.distanceFilter }).minElement() else {
            return kCLDistanceFilterNone
        }

        return value
    }

    override convenience init() {
