         return manager.coreLocationAuthorizationStatus
     }
 
-    /// The accuracy, based on the current set of listener requests.
-    private var accuracy: LocationAccuracy {
-        let allAccuracies = allLocationListeners.map({ $0.request.accuracy })
-
-        guard let value = allAccuracies.maxElement(<) else {
-            return .Good
-        }
-
-        return value
-    }
-
-    /// The update frequency, based on the current set of listener requests.
-    private var updateFrequency: LocationUpdateFrequency {
-        let allUpdateFrequencies = allLocationListeners.map({ $0.request.updateFrequency })
-
-        guard let value = allUpdateFrequencies.maxElement(<) else {
-            return .ChangesOnly
-        }
-
-        return value
-    }
-
     /// The monitoring mode for the current state.
+    ///
+    /// This takes into account the listeners' monitoring modes and the authorization status.
     private var monitoringMode: LocationMonitoring? {
-        guard !allLocationListeners.isEmpty else {
-            return nil
-        }
-
         guard authorizationStatus.allowsMonitoring else {
             return nil
         }
 
+        guard let value = allLocationListeners.map({ $0.monitoringMode }).maxElement() else {
+            return nil
+        }
+
         if authorizationStatus.requiresStandardMonitoring {
             return .Standard
         }
 
-        if accuracy.requiresStandardMonitoring {
-            return .Standard
-        }
-
-        if updateFrequency.requiresStandardMonitoring {
-            return .Standard
-        }
-
-        return .SignificantUpdates
-    }
-
-    /// The underlying location manager's desired accuracy for the current state.
+        return value
+    }
+
+    /// The desired accuracy for the current state.
     private var desiredAccuracy: CLLocationAccuracy {
-        switch accuracy {
-        case .Coarse:
-            return kCLLocationAccuracyKilometer
-        case .Good:
+        // 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
-        case .Better:
-            return kCLLocationAccuracyNearestTenMeters
-        case .Best:
-            return kCLLocationAccuracyBest
-        }
-    }
-
-    /// The underlying location manager's distance filter for the current state.
+        }
+
+        return value
+    }
+
+    /// The distance filter for the current state.
     private var distanceFilter: CLLocationDistance {
-        // To receive continuous updates, there must not be a distance filter.
-        guard updateFrequency != .Continuous else {
+        guard let value = allLocationListeners.map({ $0.distanceFilter }).minElement() 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 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
-        }
+        return value
     }
 
     override convenience init() {

            self.request = request
        }
        
        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: Comparable {
    /// 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 func < (lhs: LocationMonitoring, rhs: LocationMonitoring) -> Bool {
    switch (lhs, rhs) {
    case (.SignificantUpdates, .Standard):
        return true
    default:
        return false
    }
}

private extension LocationAccuracy {
