         let status = CLLocationManager.authorizationStatus()
         // if you're already "always" authorized, then you don't need in use
         // but the user can still demote you! So I still use them separately.
-        if status == CLAuthorizationStatus.AuthorizedWhenInUse || status == CLAuthorizationStatus.AuthorizedAlways {
+        switch status {
+        case .AuthorizedWhenInUse, .AuthorizedAlways:
             return .Authorized
-        }
-
-        return .Unknown
+        case .Restricted, .Denied:
+            return .Unauthorized
+        case .NotDetermined:
+            return .Unknown
+        }
     }
 
     func requestLocationInUse() {
         if statusLocationInUse() != .Authorized {
             locationManager.delegate = self
             locationManager.requestWhenInUseAuthorization()
+        } else if statusContacts() == .Unauthorized {
+            self.showDeniedAlert(.LocationInUse)
         }
     }
 
     public func statusContacts() -> PermissionStatus {
         let status = ABAddressBookGetAuthorizationStatus()
-        if status == ABAuthorizationStatus.Authorized {
-            return .Authorized
-        }
-
-        return .Unknown
+        switch status {
+            case .Authorized:
+                return .Authorized
+            case .Restricted, .Denied:
+                return .Unauthorized
+            case .NotDetermined:
+                return .Unknown
+        }
     }
 
     func requestContacts() {
-        if statusContacts() != .Authorized {
+        if statusContacts() == .Unknown {
             ABAddressBookRequestAccessWithCompletion(nil) { (success, error) -> Void in
                 self.detectAndCallback()
             }
+        } else if statusContacts() == .Unauthorized {
+            self.showDeniedAlert(.Contacts)
         }
     }
 

            button.center = contentView.center
            button.frame.offset(dx: -contentView.frame.origin.x, dy: -contentView.frame.origin.y)
            button.frame.offset(dx: 0, dy: -80 + CGFloat(index * baseOffset))

            let type = configuredPermissions[index].type
            switch type {
            case .LocationAlways:
                if statusLocationAlways() == .Authorized {
                    setButtonAuthorizedStyle(button)
                    button.setTitle("Got Location".uppercaseString, forState: UIControlState.Normal)
                }
            case .LocationInUse:
                if statusLocationInUse() == .Authorized {
                    setButtonAuthorizedStyle(button)
                    button.setTitle("Got Location".uppercaseString, forState: UIControlState.Normal)
                }
            case .Contacts:
                if statusContacts() == .Authorized {
                    setButtonAuthorizedStyle(button)
                    button.setTitle("Allowed Contacts".uppercaseString, forState: UIControlState.Normal)
                }
            case .Notifications:
                if statusNotifications() == .Authorized {
                    setButtonAuthorizedStyle(button)
                    button.setTitle("Allowed Notifications".uppercaseString, forState: UIControlState.Normal)
                }
            }


        let settings = UIApplication.sharedApplication().currentUserNotificationSettings()
        if settings.types != UIUserNotificationType.None {
            return .Authorized
        } else {
            return .Unauthorized
        }
        
        //        return .Unknown
    }
    
    func requestNotifications() {
        if statusNotifications() != .Authorized {
            UIApplication.sharedApplication().registerUserNotificationSettings(UIUserNotificationSettings(forTypes: .Alert | .Sound | .Badge, categories: nil))
            self.pollForNotificationChanges()
        } else if statusContacts() == .Unauthorized {
            // TODO: Alert. User must go to Settings.
            self.showDeniedAlert(.Notifications)
        }
    }
        }
    }

