         if self.locationServicesStatus == .allowedAlways ||
             self.locationServicesStatus == .allowedWhenInUse {
             
-            let request = PositionLocationRequest()
-            request.desiredAccuracy = desiredAccuracy
-            request.lifespan = OneShotRequestTimeOut
-            request.timeOutHandler = {
-                self.processLocationRequests()
-            }
-            request.completionHandler = completionHandler
-
-            if self._locationRequests == nil {
-                self._locationRequests = []
-            }
-            self._locationRequests?.append(request)
-
-            self.startLowPowerUpdating()
-            self._locationManager.desiredAccuracy = kCLLocationAccuracyBest
-            self._locationManager.distanceFilter = kCLDistanceFilterNone
-
-            if self.updatingLocation == false {
-                self.startUpdating()
+            self.executeClosureAsyncOnRequestQueueIfNecessary {
+                let request = PositionLocationRequest()
+                request.desiredAccuracy = desiredAccuracy
+                request.lifespan = OneShotRequestTimeOut
+                request.timeOutHandler = {
+                    self.processLocationRequests()
+                }
+                request.completionHandler = completionHandler
                 
-                // flag signals to turn off updating once complete
-                self.updatingLocation = false
+                self._locationRequests.append(request)
+                
+                self.startLowPowerUpdating()
+                self._locationManager.desiredAccuracy = kCLLocationAccuracyBest
+                self._locationManager.distanceFilter = kCLDistanceFilterNone
+                
+                // activate location to process request
+                if self.updatingLocation == false {
+                    self.startUpdating()
+                    // flag signals to turn off updating once complete
+                    self.updatingLocation = false
+                }
             }
             
         } else {
+            
             self.executeClosureAsyncOnMainQueueIfNecessary {
                 let error = NSError(domain: ErrorDomain, code: ErrorType.restricted.rawValue, userInfo: nil)
                 completionHandler(nil, error)
             }
+            
         }
     }
     

    
    @objc(locationManager:didUpdateLocations:)
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        self.locations = locations
    
        // update one-shot requests
        self.processLocationRequests()
    }
    
    @objc(locationManager:didFailWithError:)
    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        self.completeLocationRequestsWithError(error)
        self.delegate?.positionLocationManager(self, didFailWithError: error)
    }
    
    @objc(locationManager:didChangeAuthorizationStatus:)
    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
        switch status {
            case .denied, .restricted:
                self.completeLocationRequestsWithError(NSError(domain: ErrorDomain, code: ErrorType.restricted.rawValue, userInfo: nil))
                break
            default:
                break
        }
        self.delegate?.positionLocationManager(self, didChangeLocationAuthorizationStatus: self.locationServicesStatus)
    }
    
    @objc(locationManager:didDetermineState:forRegion:)

            closure()
        } else {
            DispatchQueue.main.sync(execute: closure)
        }
    }
    
    internal func executeClosureAsyncOnRequestQueueIfNecessary(withClosure closure: @escaping () -> Void) {
        if DispatchQueue.getSpecific(key: PositionRequestQueueSpecificKey) == self._requestQueue {
            closure()
        } else {
            self._requestQueue.async(execute: closure)
        }
    }
    
