APP启动时权限的判断包括语音，图片，视频，音频等等

.h文件

import <Foundation/Foundation.h>

/** 权限类型 */
typedef NS_ENUM(NSUInteger, YYAuthorizationType) {
YYAuthorizationTypePhotos = 0, // 相册
YYAuthorizationTypeCamera, // 相机
YYAuthorizationTypeMicrophone, // 麦克风
YYAuthorizationTypeCameraAndMicrophone, // 相机和麦克风 (视频)
YYAuthorizationTypeLocation, // 位置
YYAuthorizationTypeNotification, // 通知
};

/** 权限状态 */
typedef NS_ENUM(NSUInteger, YYAuthorizationStatus) {
YYAuthorizationStatusNotDetermined = 0, // 未询问
YYAuthorizationStatusNoPermission, // 无权限
YYAuthorizationStatusHavePermission, // 有权限
};

@interface YYSystemAuthorization : NSObject

/** 检测用户是否有权限访问通知 */
@property (nonatomic, assign) BOOL isCanUseNotification;

(YYSystemAuthorization *)sharedSystemAuthorization;

/**
程序进入后台
*/

(void)applicationDidEnterBackground:(UIApplication *)application;

/**
检测某种权限的权限状态 (不包含通知, 通知的权限用"isCanUseNotification"判断)

@param authType 权限类型
@return 当前的权限状态
*/

(YYAuthorizationStatus)authorizationStatusForAuthType:(YYAuthorizationType)authType;

/**
检测权限并引导去开启

@param authType 权限类型
@param viewController 相关视图控制器
@param completion 点击确定后回调 (havePermission:是否有权限)
*/

(void)detectionAuthAndGuideToOpen:(YYAuthorizationType)authType viewController:(UIViewController *)viewController completion:(void (^)(BOOL havePermission))completion;

/**
无权限, 引导去开启 (不进行权限检测)

@param authType 权限类型
@param viewController 相关视图控制器
@param completion 点击确定后回调 (havePermission:是否有权限)
*/

(void)guideToOpenAuth:(YYAuthorizationType)authType viewController:(UIViewController *)viewController completion:(void (^)(BOOL havePermission))completion;

.m文件

import "YYSystemAuthorization.h"

import <Photos/Photos.h>

import <AVFoundation/AVFoundation.h>

import <CoreLocation/CoreLocation.h>

@interface YYSystemAuthorization () <CLLocationManagerDelegate>

/** 相关视图控制器 */
@property (nonatomic, weak) UIViewController *viewController;

/** 点击确定后回调 */
@property (nonatomic, copy) void (^completion)(BOOL havePermission);

/** 位置权限管理对象 */
@property (nonatomic, strong) CLLocationManager *locationManager;

@end

@implementation YYSystemAuthorization

(YYSystemAuthorization *)sharedSystemAuthorization {
static dispatch_once_t onceToken;
static YYSystemAuthorization *instance;
dispatch_once(&onceToken, ^{
instance = [[YYSystemAuthorization alloc] init];
});
return instance;
}

/** 程序进入后台 */

(void)applicationDidEnterBackground:(UIApplication *)application {
if (self.completion) {
self.completion = nil;
}
}

pragma mark - 某种权限的权限状态

/** 某种权限的权限状态 */

(YYAuthorizationStatus)authorizationStatusForAuthType:(YYAuthorizationType)authType {
switch (authType) {
case YYAuthorizationTypePhotos: // 相册
return [self photosAuthorizationStatus];
break;
case YYAuthorizationTypeCamera: // 相机
return [self cameraAuthorizationStatus];
break;
case YYAuthorizationTypeMicrophone: // 麦克风
return [self microphoneAuthorizationStatus];
break;
case YYAuthorizationTypeLocation: // 位置
return [self locationAuthorizationStatus];
break;
```
  default:
      return YYAuthorizationStatusNotDetermined;
      break;
```
}
}

pragma mark - 检测权限并引导去开启

/** 检测权限并引导去开启 */

(void)detectionAuthAndGuideToOpen:(YYAuthorizationType)authType viewController:(UIViewController *)viewController completion:(void (^)(BOOL havePermission))completion {
self.viewController = viewController;
self.completion = completion;
switch (authType) {
case YYAuthorizationTypePhotos: // 相册
[self detectionPhotosAuthAndGuideToOpen];
break;
case YYAuthorizationTypeCamera: // 相机
[self detectionCameraAuthAndGuideToOpen];
break;
case YYAuthorizationTypeMicrophone: // 麦克风
[self detectionMicrophoneAuthAndGuideToOpen];
break;
case YYAuthorizationTypeCameraAndMicrophone: // 相机和麦克风
[self detectionCameraAndMicrophoneAuthAndGuideToOpen];
break;
case YYAuthorizationTypeLocation: // 位置
[self detectionLocationAuthAndGuideToOpen];
break;
case YYAuthorizationTypeNotification: // 通知
[self detectionNotificationAuthAndGuideToOpen];
break;
```
  default:
      break;
```
}
}

/** 无权限, 引导去开启 (不进行权限检测) */

(void)guideToOpenAuth:(YYAuthorizationType)authType viewController:(UIViewController *)viewController completion:(void (^)(BOOL havePermission))completion {
self.viewController = viewController;
self.completion = completion;
[self handleNoPermissionOfType:authType];
}

pragma mark - 相册

/** 检测相册权限并引导去开启 */

(void)detectionPhotosAuthAndGuideToOpen {
YYAuthorizationStatus authStatus = [self photosAuthorizationStatus];
if (authStatus == YYAuthorizationStatusNotDetermined) { // 未询问
// 第一次询问用户是否进行授权
// 下面的方法只会在未询问过用户的情况下生效，也就是只能第一次询问的时候调用，如果第一次调用时点击了不允许，再次监测状态时调用无效，只能提示用户去设置中打开开关。
[PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus status) {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
if (status == PHAuthorizationStatusAuthorized) {
self.completion(YES);
} else {
self.completion(NO);
}
}
});
}];
} else if (authStatus == YYAuthorizationStatusNoPermission) { // 无权限
[self handleNoPermissionOfType:YYAuthorizationTypePhotos];
} else { // 有权限
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
}
}

/** 检测用户的相册权限 */

(YYAuthorizationStatus)photosAuthorizationStatus {
PHAuthorizationStatus authStatus = [PHPhotoLibrary authorizationStatus];
// 用户尚未做出选择
if (authStatus == PHAuthorizationStatusNotDetermined) { // 未询问
return YYAuthorizationStatusNotDetermined;
} else if (authStatus == PHAuthorizationStatusRestricted || authStatus == PHAuthorizationStatusDenied) { // 无权限
// 此应用程序没有被授权访问的照片数据
// 用户已经明确否认了这一照片数据的应用程序访问
return YYAuthorizationStatusNoPermission;
}
// 有权限
return YYAuthorizationStatusHavePermission;
}

pragma mark - 相机

/** 检测相机权限并引导去开启 */

(void)detectionCameraAuthAndGuideToOpen {
YYAuthorizationStatus authStatus = [self cameraAuthorizationStatus];
if (authStatus == YYAuthorizationStatusNotDetermined) { // 未询问
// 第一次询问用户是否进行授权
// 下面的方法只会在未询问过用户的情况下生效，也就是只能第一次询问的时候调用，如果第一次调用时点击了不允许，再次监测状态时调用无效，只能提示用户去设置中打开开关。
[AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
if (!granted) {
[self handleClickUnallowed];
}
}];
} else if (authStatus == YYAuthorizationStatusNoPermission) { // 无权限
[self handleNoPermissionOfType:YYAuthorizationTypeCamera];
} else { // 有权限
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
}
}

/** 检测用户的相机权限 */

(YYAuthorizationStatus)cameraAuthorizationStatus {
AVAuthorizationStatus authStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
if (authStatus == AVAuthorizationStatusNotDetermined) { // 用户尚未做出选择
return YYAuthorizationStatusNotDetermined;
} else if (authStatus == AVAuthorizationStatusRestricted || authStatus == AVAuthorizationStatusDenied) { // 无权限
// 受限制的
// 不允许
return YYAuthorizationStatusNoPermission;
}
// 有权限
return YYAuthorizationStatusHavePermission;
}

pragma mark - 麦克风

/** 检测麦克风权限并引导去开启 */

(void)detectionMicrophoneAuthAndGuideToOpen {
YYAuthorizationStatus authStatus = [self microphoneAuthorizationStatus];
if (authStatus == YYAuthorizationStatusNotDetermined) { // 未询问
// 第一次询问用户是否进行授权
// [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL granted) {
//
// }];
// iOS8.0
[[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) {
if (!granted) {
[self handleClickUnallowed];
}
}];
} else if (authStatus == YYAuthorizationStatusNoPermission) { // 无权限
[self handleNoPermissionOfType:YYAuthorizationTypeMicrophone];
} else { // 有权限
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
}
}

/** 检测用户的麦克风权限 */

(YYAuthorizationStatus)microphoneAuthorizationStatus {
/**
AVAuthorizationStatus authStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
if (authStatus == AVAuthorizationStatusNotDetermined) { // 用户尚未做出选择
return YYAuthorizationStatusNotDetermined;
} else if (authStatus == AVAuthorizationStatusRestricted || authStatus == AVAuthorizationStatusDenied) { // 无权限
// 受限制的
// 不允许
return YYAuthorizationStatusNoPermission;
}
// 有权限
return YYAuthorizationStatusHavePermission;
*/

// iOS8.0
AVAudioSessionRecordPermission recordPermission = [[AVAudioSession sharedInstance] recordPermission];
if (recordPermission == AVAudioSessionRecordPermissionUndetermined) { // 用户尚未做出选择
return YYAuthorizationStatusNotDetermined;
} else if (recordPermission == AVAudioSessionRecordPermissionDenied) { // 无权限
return YYAuthorizationStatusNoPermission;
} else { // 有权限
return YYAuthorizationStatusHavePermission;
}
}

pragma mark - 相机和麦克风

/** 检测相机和麦克风权限并引导去开启 */

(void)detectionCameraAndMicrophoneAuthAndGuideToOpen {
__block YYAuthorizationStatus cameraStatus = [self cameraAuthorizationStatus];
__block YYAuthorizationStatus microphoneStatus = [self microphoneAuthorizationStatus];

// 相机和麦克风都有权限
if (cameraStatus == YYAuthorizationStatusHavePermission && microphoneStatus == YYAuthorizationStatusHavePermission) {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
return;
}

// 相机和麦克风都不是第一次询问授权
if (cameraStatus != YYAuthorizationStatusNotDetermined && microphoneStatus != YYAuthorizationStatusNotDetermined) {
if (cameraStatus == YYAuthorizationStatusNoPermission && microphoneStatus == YYAuthorizationStatusNoPermission) { // 相机和麦克风都没有权限
[self handleNoPermissionOfType:YYAuthorizationTypeCameraAndMicrophone];
} else if (cameraStatus == YYAuthorizationStatusNoPermission) { // 相机没有权限
[self handleNoPermissionOfType:YYAuthorizationTypeCamera];
} else if (microphoneStatus == YYAuthorizationStatusNoPermission) { // 麦克风没有权限
[self handleNoPermissionOfType:YYAuthorizationTypeMicrophone];
}
return;
}

// 第一次询问用户是否进行授权
if (cameraStatus == YYAuthorizationStatusNotDetermined) { // 相机未询问
[AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
if (granted) { // 允许
cameraStatus = YYAuthorizationStatusHavePermission;
// 相机和麦克风都有权限
if (microphoneStatus == YYAuthorizationStatusHavePermission) {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
} else if (microphoneStatus == YYAuthorizationStatusNoPermission) {
// 麦克风没有权限
[self handleNoPermissionOfType:YYAuthorizationTypeMicrophone];
}
} else { // 不允许
if (microphoneStatus == YYAuthorizationStatusNoPermission) {
[self handleClickUnallowed];
}
}
}];
}

if (microphoneStatus == YYAuthorizationStatusNotDetermined) { // 麦克风未询问
[[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) {
if (granted) { // 允许
// 相机和麦克风都有权限
if (cameraStatus == YYAuthorizationStatusHavePermission) {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
} else if (cameraStatus == YYAuthorizationStatusNoPermission) {
// 相机没有权限
[self handleNoPermissionOfType:YYAuthorizationTypeCamera];
}
} else { // 不允许
[self handleClickUnallowed];
}
}];
}
}

pragma mark - 位置

/** 检测位置权限并引导去开启 */

(void)detectionLocationAuthAndGuideToOpen {
YYAuthorizationStatus authStatus = [self locationAuthorizationStatus];
if (authStatus == YYAuthorizationStatusNotDetermined) { // 未询问
// 获取定位授权
[self requestLocationServicesAuthorization];
} else if (authStatus == YYAuthorizationStatusNoPermission) { // 无权限
[self handleNoPermissionOfType:YYAuthorizationTypeLocation];
} else { // 有权限
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
}
}

/** 检测用户的位置权限 */

(YYAuthorizationStatus)locationAuthorizationStatus {
CLAuthorizationStatus authStatus = [CLLocationManager authorizationStatus];
if (authStatus == kCLAuthorizationStatusNotDetermined) { // 用户尚未做出选择
return YYAuthorizationStatusNotDetermined;
} else if (authStatus == kCLAuthorizationStatusRestricted || authStatus == kCLAuthorizationStatusDenied) { // 无权限
// 受限制的
// 不允许
return YYAuthorizationStatusNoPermission;
}
// 有权限
return YYAuthorizationStatusHavePermission;
}

/** 获取定位授权 */

(void)requestLocationServicesAuthorization {
// CLLocationManager的实例对象一定要保持生命周期的存活
if (!self.locationManager) {
self.locationManager = [[CLLocationManager alloc] init];
self.locationManager.delegate = self;
}

// 使用的时候获取定位信息
[self.locationManager requestWhenInUseAuthorization];
// 一直获取定位信息
//[self.locationManager requestAlwaysAuthorization];
}

pragma mark - CLLocationManagerDelegate

/** 定位授权状态改变 */

(void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status {
//self.locationManager = nil;
// 有权限
if (status == kCLAuthorizationStatusAuthorizedAlways || status == kCLAuthorizationStatusAuthorizedWhenInUse) {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
} else {
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(NO);
}
});
}
}

pragma mark - 通知

/** 检测通知权限并引导去开启 */

(void)detectionNotificationAuthAndGuideToOpen {
// 检测通知权限
if (![self isCanUseNotification]) {
// 无权限
[self handleNoPermissionOfType:YYAuthorizationTypeNotification];
} else { // 有权限
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(YES);
}
});
}
}

/** 检测用户是否有权限访问通知 */

(BOOL)isCanUseNotification {
// 推送关闭
if ([UIApplication sharedApplication].currentUserNotificationSettings.types == UIUserNotificationTypeNone) {
// 无权限
return NO;
}
return YES;
}

pragma mark - 第一次询问授权时, 用户点击了"不允许" 处理

(void)handleClickUnallowed {
dispatch_async(dispatch_get_main_queue(), ^{
[self.viewController dismissViewControllerAnimated:YES completion:nil];
if (self.completion) {
self.completion(NO);
}
});
}

pragma mark - 无权限处理

(void)handleNoPermissionOfType:(YYAuthorizationType)authType {
NSString *alertTitle = nil;
switch (authType) {
case YYAuthorizationTypePhotos: // 相册
alertTitle = @"请在iPhone的“设置-隐私-照片”选项中，允许%@访问你的照片。";
break;
case YYAuthorizationTypeCamera: // 相机
alertTitle = @"请在iPhone的“设置-隐私-相机”选项中，允许%@访问你的相机。";
break;
case YYAuthorizationTypeMicrophone: // 麦克风
alertTitle = @"请在iPhone的“设置-隐私-麦克风”选项中，允许%@访问你的麦克风。";
break;
case YYAuthorizationTypeCameraAndMicrophone: // 相机和麦克风
alertTitle = @"请在iPhone的“设置-隐私”选项中，允许%@访问你的相机和麦克风。";
break;
case YYAuthorizationTypeLocation: // 位置
alertTitle = @"无法获取你的位置信息。\n请到手机系统的[设置]->[隐私]->[定位服务]中打开定位服务，并允许%@使用定位服务。";
break;
case YYAuthorizationTypeNotification: // 通知
alertTitle = @"你现在无法收到新消息通知。\n请到系统“设置”-“通知”-“%@”中开启。";
```
      break;
      
  default:
      break;
```
}

UIAlertController *alertController = [UIAlertController alertControllerWithTitle:[NSString stringWithFormat:alertTitle, kAppName] message:nil preferredStyle:UIAlertControllerStyleAlert];

if (authType == YYAuthorizationTypeNotification) {
[alertController addAction:[UIAlertAction actionWithTitle:@"以后" style:UIAlertActionStyleDefault handler:^(UIAlertAction * _Nonnull action) {
// 回调
dispatch_async(dispatch_get_main_queue(), ^{
if (self.completion) {
self.completion(NO);
}
});
}]];
}

[alertController addAction:[UIAlertAction actionWithTitle:@"确定" style:UIAlertActionStyleDefault handler:^(UIAlertAction * _Nonnull action) {
dispatch_async(dispatch_get_main_queue(), ^{
if (authType == YYAuthorizationTypeNotification) {
// 引导去开启
[self guideToOpenAuthorization];
} else {
[self.viewController dismissViewControllerAnimated:YES completion:nil];
}
```
      // 回调
      if (self.completion) {
          self.completion(NO);
      }
  });
```
}]];
[self.viewController presentViewController:alertController animated:YES completion:nil];
}

/** 引导去开启相关权限 */

(void)guideToOpenAuthorization {
NSURL *url = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
if ([[UIApplication sharedApplication] canOpenURL:url]) {
if (@available(iOS 10.0, *)) {
[[UIApplication sharedApplication] openURL:url options:@{} completionHandler:^(BOOL success) {
```
      }];
  } else {
      [[UIApplication sharedApplication] openURL:url];
  }
```
}
}