Why am I not getting didEnterRegion or didExitRegion calls when using CLLocationManager's startMonitoringForRegion

Question

I am trying to set up a client's app to trigger a database update when the iOS device arrives at/leaves the office.

(It's an app for my client's salespeople to use in the field, where some customer sites do not have any network connectivity, so the client wants the database updated as the salespeople leaves the office/return to the office.)

I am never getting didEnterRegion or didExitRegion calls.

I have a singleton RegionsManager that manages an instance of the location manager. I am using CLLocationManager and the startMonitoringForRegion method.

On launch, I invoke the the RegionsManager which creates a location manager and set itself up as the delegate of the location manager.

In my app delegate's didFinishLaunchingWithOptions method I check for the UIApplicationLaunchOptionsLocationKey, in case I'm being relaunched for a region entered/exited, but that never happens.

I have a NSLocationAlwaysUsageDescription key/value pair in info.plist.

I call CLLocationManager.authorizationStatus to make sure the app is authorized, and if not I call requestAlwaysAuthorization.

Once I verify that the app is authorized, I also check isMonitoringAvailableForClass(CLCircularRegion).

Assuming monitoring is available, I then check to see if the location manager's set of monitoredRegions already contains the region I am about to create (I just check the coordinate). If so, I skip adding the region.

If the location manager is not yet monitoring the region, I add it with a call to startMonitoringForRegion.

On the second launch of the app, I see the regions that I added on the last launch in the location manager's set of monitoredRegions, so I know they are being added.

The code to set all this up is quite involved, since it is set up to handle adding multiple regions, and also has logic to maintain an array of the regions being monitored and a block that should be invoked if the on a didEnterRegion or didExitRegion message.

Here is the method in question in it's (rather long) entirety:

func startMonitoring(#coordinate: CLLocationCoordinate2D,
  radius: CLLocationDistance = regionDistance,
  id: String = "",
  notificationBlock: regionNotificationBlock)
{
  var authorizationStatus = CLLocationManager.authorizationStatus()
  if !locationManagerReady
  {
    //Make sure we're authorized to use the location manager.
    if authorizationStatus == .NotDetermined && !waitingForAuthorization
    {
      //We haven't been authorized yet. Trigger a prompt to the user.
      theLocationMgr.requestAlwaysAuthorization()
      waitingForAuthorization = true
      authorizationStatus = CLLocationManager.authorizationStatus()
    }

    //Wait for the user to grant/deny permission.
    if authorizationStatus == .NotDetermined
    {
      //After 1 second, re-call this method to try again.
      delay(1.0)
        {
          ()-> () in
          self.startMonitoring(
            coordinate: coordinate,
            radius: radius,
            id: id,
            notificationBlock: notificationBlock)
      }
      return
    }

    let rootVC: UIViewController? = UIApplication.sharedApplication().keyWindow?.rootViewController
    if authorizationStatus == CLAuthorizationStatus.Restricted ||
      authorizationStatus == CLAuthorizationStatus.Denied
    {
      Utils.showAlertOnVC(
        rootVC,
        title: "Location manager error",
        message: "Permission to access location denied")
      return
    }

    else if !CLLocationManager.isMonitoringAvailableForClass(CLCircularRegion)
    {
      Utils.showAlertOnVC(
        rootVC,
        title: "Location manager error",
        message: "geofencing is not available.")
      return
    }
  }
  if !locationManagerReady
  {
    locationManagerReady = true
    theLocationMgr.desiredAccuracy = kCLLocationAccuracyBest
    theLocationMgr.distanceFilter = kCLDistanceFilterNone;
  }

  //If we get here, we're done configuring the location manager

  //If this region is already in our array of regions, don't add it again.
  if let existingRegionIndex = regionIndexForCoordinate(coordinate)
  {
    return
  }
  let regionToMonitor =  CLCircularRegion(
    center: coordinate,
    radius: radius,
    identifier: id)


  //See if the system is still monitoring this region from a previous launch.
  var found = false
  var foundRegion: CLCircularRegion? = nil
  if let monitoredRegions = theLocationMgr.monitoredRegions as NSSet?
  {
    let regionsArray = monitoredRegions.allObjects as NSArray
    let regionIndex = regionsArray.indexOfObjectPassingTest()
      { (object, index, flag) -> Bool in
        if let region = object as? CLCircularRegion
        {
          return region.center.latitude == coordinate.latitude &&
            region.center.longitude == coordinate.longitude
        }
        else
        {
          return false
        }
    }
    found = regionIndex != NSNotFound
    if found
    {
      foundRegion = regionsArray[regionIndex] as? CLCircularRegion
    }
  }
  if found
  {
    logToFile("already monitoring (\(coordinate.latitude),\(coordinate.longitude)). ID = '\(foundRegion!.identifier!)'")
  }
  else
  {
    logToFile("Adding geofence for (\(coordinate.latitude),\(coordinate.longitude)). ID = '\(id)'")
    theLocationMgr.startMonitoringForRegion(regionToMonitor)
  }
  let aRegionEntry = RegionEntry(region: regionToMonitor, regionNoticeBlock: notificationBlock)
  regionsBeingMonitored.append(aRegionEntry)
}

My RegionsManager class has an array regionsBeingMonitored of RegionEntry objects:

lazy var regionsBeingMonitored = [RegionEntry]()

Here is the RegionEntry object:

class RegionEntry: NSObject
{
  var theRegion: CLCircularRegion?
  var theRegionNoticeBlock: regionNotificationBlock?
  init(region: CLCircularRegion?, regionNoticeBlock: regionNotificationBlock?)
  {
    theRegion = region
    theRegionNoticeBlock = regionNoticeBlock
  }
}

It also has state flags to keep track of the setup of the location manager:

var waitingForAuthorization: Bool = false
var locationManagerReady: Bool = false

I have gone over the documentation on setting up region monitoring quite carefully and am pretty confident I am doing all the setup I am supposed to be doing.

My didEnterRegion and didExitRegion methods write a message to a log file as soon as they are called, so even if there is a problem with my logic for matching a region with an entry in my regionsBeingMonitored array I should still see the log entry:

func locationManager(manager: CLLocationManager!,
  didEnterRegion region: CLRegion!)
{
  logToFile("In \(__FUNCTION__). region = \(region)")
  if let region = region as? CLCircularRegion
  {
    if let regionIndex = regionIndexForCoordinate(region.center)
    {
      let aRegionEntry = regionsBeingMonitored[regionIndex]
      aRegionEntry.theRegionNoticeBlock?(region: region, didEnter: true)
    }
  }
}

func locationManager(manager: CLLocationManager!,
  didExitRegion region: CLRegion!)
{
  logToFile("In \(__FUNCTION__). region = \(region)")
  if let region = region as? CLCircularRegion
  {
    if let regionIndex = regionIndexForCoordinate(region.center)
    {
      let aRegionEntry = regionsBeingMonitored[regionIndex]
      aRegionEntry.theRegionNoticeBlock?(region: region, didEnter: false)
    }
  }
}

Do you see anything that I might be doing wrong? The method signature for my didEnterRegion or didExitRegion looks correct, so I don't think that's it.