從iOS 10開始獲取用戶隱私數(shù)據(jù)都需要在info.plist文件中配置對應(yīng)的權(quán)限赵抢。在沒有配置權(quán)限下調(diào)系統(tǒng)接口直接閃退瘾晃，也是很蘋果搀愧。

目前涉及16種隱私權(quán)限少态，分別是藍(lán)牙城侧、日歷、相機(jī)彼妻、通訊錄嫌佑、Face ID豆茫、健康分享、住宅配件屋摇、位置揩魂、麥克風(fēng)、運(yùn)動與健身炮温、媒體與Apple Music火脉、NFC、相冊柒啤、提醒事項(xiàng)倦挂、Siri、 語音識別担巩。

配置權(quán)限的XML格式

<!-- 藍(lán)牙 -->
<key>NSBluetoothPeripheralUsageDescription</key>
<string>App需要您的同意,才能訪問藍(lán)牙</string>

<!-- 日歷 -->
<key>NSCalendarsUsageDescription</key>
<string>App需要您的同意,才能訪問日歷</string>

<!-- 相機(jī) -->
<key>NSCameraUsageDescription</key>
<string>App需要您的同意,才能訪問相機(jī)</string>

<!-- 通訊錄 -->
<key>NSContactsUsageDescription</key>
<string>App需要您的同意,才能訪問通訊錄</string>

<!-- Face ID --> 
<key>NSFaceIDUsageDescription</key>
<string>App需要您的同意,才能訪問Face ID</string>

<!-- 健康分享 --> 
<key>NSHealthShareUsageDescription</key>
<string>App需要您的同意,才能訪問健康分享</string>

<!-- 健康更新 -->
<key>NSHealthUpdateUsageDescription</key>
<string>App需要您的同意,才能訪問健康更新 </string>

<!-- 住宅配件 --> 
<key>NSHomeKitUsageDescription</key>
<string>App需要您的同意,才能訪問住宅配件 </string>

<!-- 位置 -->
<key>NSLocationUsageDescription</key>
<string>App需要您的同意,才能訪問位置</string>

<!-- 始終訪問位置 -->
<key>NSLocationAlwaysUsageDescription</key>
<string>App需要您的同意,才能始終訪問位置</string>

<!-- 在使用期間訪問位置 -->
<key>NSLocationWhenInUseUsageDescription</key>
<string>App需要您的同意,才能在使用期間訪問位置</string>

<!-- 麥克風(fēng) -->
<key>NSMicrophoneUsageDescription</key>
<string>App需要您的同意,才能訪問麥克風(fēng)</string>

<!-- 運(yùn)動與健身 -->
<key>NSMotionUsageDescription</key>
<string>App需要您的同意,才能訪問運(yùn)動與健身</string>

<!-- 媒體資料庫 -->
<key>NSAppleMusicUsageDescription</key>
<string>App需要您的同意,才能訪問媒體資料庫</string>

<!-- NFC -->
<key>NFCReaderUsageDescription</key>
<string>App需要您的同意,才能訪問NFC</string>

<!-- 相冊 -->
<key>NSPhotoLibraryUsageDescription</key>
<string>App需要您的同意,才能訪問相冊</string>

<!-- 提醒事項(xiàng) -->
<key>NSRemindersUsageDescription</key>
<string>App需要您的同意,才能訪問提醒事項(xiàng)</string>

<!-- Siri -->
<key>NSSiriUsageDescription</key>
<string>App需要您的同意,才能使用Siri功能</string> 

<!-- 語音識別 -->
<key>NSSpeechRecognitionUsageDescription</key>
<string>App需要您的同意,才能使用語音識別功能</string> 

<!-- 電視提供商 -->
<key>NSVideoSubscriberAccountUsageDescription</key>
<string>App需要您的同意,才能訪問電視提供商</string> 

需要引入的庫

#import <CoreBluetooth/CoreBluetooth.h>
#import <EventKit/EventKit.h>
#import <AVFoundation/AVFoundation.h>
#import <Contacts/Contacts.h>
#import <LocalAuthentication/LocalAuthentication.h>
#import <HealthKit/HealthKit.h>
#import <HomeKit/HomeKit.h>
#import <CoreLocation/CoreLocation.h>
#import <CoreMotion/CoreMotion.h>
#import <StoreKit/StoreKit.h>
#import <CoreNFC/CoreNFC.h>
#import <Photos/Photos.h>
#import <Intents/Intents.h>
#import <Speech/Speech.h>

Capabilities中開啟相應(yīng)開關(guān)

Capabilities.png

請求獲取隱私權(quán)限

#pragma mark - 請求訪問藍(lán)牙權(quán)限
- (void)requestAccessBluetoothWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock  {
    self.bluetoothManager = [[CBCentralManager alloc]initWithDelegate:self queue:nil];
    self.bluetoothStateCompletionBlock = completionBlock;
}

#pragma mark - CBCentralManagerDelegate
- (void)centralManagerDidUpdateState:(CBCentralManager *)central {
    CBManagerState state = central.state;
    
    WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if (state == CBManagerStateResetting) { // 重置或重新連接
        wtState = WTAuthorizationStateUnkonw;
    } else if (state == CBManagerStateUnsupported) {
        wtState = WTAuthorizationStateUnsupported;
    } else if (state == CBManagerStateUnauthorized) {
        wtState = WTAuthorizationStateUnauthorized;
    } else if (state == CBManagerStatePoweredOff) {
        wtState = WTAuthorizationStateDenied;
    } else if (state == CBManagerStatePoweredOn) {
        wtState = WTAuthorizationStateAuthorized;
    }
    
    [self respondWithState:wtState CompletionBlock:self.bluetoothStateCompletionBlock];
}

#pragma mark - 請求日歷訪問權(quán)限
- (void)requestAccessCalendarWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    EKAuthorizationStatus status = [EKEventStore authorizationStatusForEntityType:EKEntityTypeEvent];
    
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if (status == EKAuthorizationStatusNotDetermined) {
        EKEventStore *store = [[EKEventStore alloc] init];
        __weak __typeof(self)weakSelf = self;
        [store requestAccessToEntityType:EKEntityTypeEvent completion:^(BOOL granted, NSError *error) {
            if (error) {} else {
                if (granted) {
                    wtState = WTAuthorizationStateAuthorized;
                } else {
                    wtState = WTAuthorizationStateDenied;
                }
            }
            
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == EKAuthorizationStatusRestricted) {
        wtState = WTAuthorizationStateUnkonw;
    } else if (status == EKAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

 #pragma mark - 請求相機(jī)訪問權(quán)限
- (void)requestAccessCameraWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if ([UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera]) {
    
        AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
        
        if (status == AVAuthorizationStatusNotDetermined) {
            
            [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
                if (granted) {
                    wtState = WTAuthorizationStateAuthorized;
                }else{
                    wtState = WTAuthorizationStateDenied;
                }
                [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
            }];
            return;
        } else if (status == AVAuthorizationStatusRestricted) {
        } else if (status == AVAuthorizationStatusDenied) {
            wtState = WTAuthorizationStateDenied;
        } else {
            wtState = WTAuthorizationStateAuthorized;
        }
        
    } else {
        wtState = WTAuthorizationStateUnsupported;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - 請求通訊錄訪問權(quán)限
- (void)requestAccessContactsWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    CNAuthorizationStatus status = [CNContactStore authorizationStatusForEntityType:CNEntityTypeContacts];
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if (status == CNAuthorizationStatusNotDetermined) {
        CNContactStore *contactStore = [[CNContactStore alloc] init];
        [contactStore requestAccessForEntityType:CNEntityTypeContacts completionHandler:^(BOOL granted, NSError *error) {
            if (error) {} else {
                if (granted) {
                    wtState = WTAuthorizationStateAuthorized;
                } else {
                    wtState = WTAuthorizationStateDenied;
                }
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == CNAuthorizationStatusRestricted) {
    } else if (status == CNAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - Face ID訪問權(quán)限
- (void)requestAccessFaceIDWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    if ([UIDevice currentDevice].systemVersion.floatValue < 11.0f) {
        [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:completionBlock];
    }
    LAContext *authenticationContext = [[LAContext alloc]init];
    NSError *error = nil;
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    BOOL canEvaluatePolicy = [authenticationContext canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics error:&error];
    if (canEvaluatePolicy) {
        if (authenticationContext.biometryType == LABiometryTypeFaceID) {
            [authenticationContext evaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics localizedReason:@"" reply:^(BOOL success, NSError * _Nullable error) {
                if (error) {} else {
                    if (success) {
                        wtState = WTAuthorizationStateAuthorized;
                    } else {
                        wtState = WTAuthorizationStateDenied;
                    }
                }
                [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
            }];
            return;
        } else {
            wtState = WTAuthorizationStateUnsupported;
        }
    }
    
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - 獲取健康心率 需要具體權(quán)限可以修改 HKQuantityTypeIdentifier
- (void)requestAccessHealthWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if ([HKHealthStore isHealthDataAvailable]) {
        HKHealthStore *healthStore = [[HKHealthStore alloc] init];
        __weak __typeof(self)weakSelf = self;
        HKQuantityType *heartRateType = [HKQuantityType quantityTypeForIdentifier:HKQuantityTypeIdentifierHeartRate];
        HKAuthorizationStatus status = [healthStore authorizationStatusForType:heartRateType];
        
        if (status == HKAuthorizationStatusNotDetermined) {
            NSSet *typeSet = [NSSet setWithObject:heartRateType];
            [healthStore requestAuthorizationToShareTypes:typeSet readTypes:typeSet completion:^(BOOL success, NSError * _Nullable error) {
                if (success) {
                    HKAuthorizationStatus status = [healthStore authorizationStatusForType:heartRateType];
                    if (status == HKAuthorizationStatusNotDetermined) {
                        wtState = WTAuthorizationStateUnauthorized;
                    } else if (status == HKAuthorizationStatusSharingAuthorized) {
                        wtState = WTAuthorizationStateAuthorized;
                    } else {
                        wtState = WTAuthorizationStateDenied;
                    }
                }
                [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
            }];
            return;
        } else if (status == HKAuthorizationStatusSharingAuthorized) {
            wtState = WTAuthorizationStateAuthorized;
        } else {
            wtState = WTAuthorizationStateDenied;
        }
    } else {
        wtState = WTAuthorizationStateUnsupported;
    }
    
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - HomeKit
- (void)requestAccessHomeKitWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    self.homeManager = [[HMHomeManager alloc] init];
    self.homeManager.delegate = self;
    self.homeKitCompletionBlock = completionBlock;
}

#pragma mark - HMHomeManagerDelegate
- (void)homeManagerDidUpdateHomes:(HMHomeManager *)manager {
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    if (manager.homes.count > 0) {
        wtState = WTAuthorizationStateAuthorized;
       [self respondWithState:wtState CompletionBlock:self.homeKitCompletionBlock];
    } else {
        __weak __typeof(self)weakSelf = self;
        __weak HMHomeManager *weakHomeManager = manager;
        [manager addHomeWithName:@"Test Home" completionHandler:^(HMHome * _Nullable home, NSError * _Nullable error) {
            if (error) {
                wtState = WTAuthorizationStateAuthorized;
            } else {
                if (error.code == HMErrorCodeHomeAccessNotAuthorized) {
                    wtState = WTAuthorizationStateDenied;
                }
            }
            
            [weakSelf respondWithState:wtState CompletionBlock:self.homeKitCompletionBlock];
            
            if (home) {
                [weakHomeManager removeHome:home completionHandler:^(NSError * _Nullable error) {
                }];
            }
        }];
    }
}

#pragma mark - 位置訪問權(quán)限
- (void)requestAccessLocationWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    self.locationCompletionBlock = completionBlock;
    self.locationManager = [[CLLocationManager alloc] init];
    self.locationManager.delegate = self;
    [self.locationManager requestWhenInUseAuthorization];
    [self.locationManager startUpdatingLocation];
}

#pragma mark - CLLocationManagerDelegate
- (void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status {
    WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    switch (status) {
        case kCLAuthorizationStatusNotDetermined:{
            wtState = WTAuthorizationStateUnauthorized;
            break;
        }
        case kCLAuthorizationStatusRestricted:{
            break;
        }
        case kCLAuthorizationStatusDenied:{
            wtState = WTAuthorizationStateDenied;
            break;
        }
        case kCLAuthorizationStatusAuthorizedAlways:{
            wtState = WTAuthorizationStateAuthorized;
            break;
        }
        case kCLAuthorizationStatusAuthorizedWhenInUse:{
            wtState = WTAuthorizationStateAuthorized;
            break;
        }
        default:
            break;
    }
    [self respondWithState:wtState CompletionBlock:self.locationCompletionBlock];
}

#pragma mark - 麥克風(fēng)
- (void)requestAccessMicrophoneWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __weak __typeof(self)weakSelf = self;
   __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
    
    if (status == AVAuthorizationStatusNotDetermined) {
        [[AVAudioSession sharedInstance] requestRecordPermission:^(BOOL granted) {
            if (granted) {
                wtState = WTAuthorizationStateAuthorized;
            } else {
                wtState = WTAuthorizationStateDenied;
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == AVAuthorizationStatusRestricted) {
    } else if (status == AVAuthorizationStatusDenied) {
       wtState = WTAuthorizationStateDenied;
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - 運(yùn)動與健身 不需要回調(diào)
- (void)requestAccessMotionWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __weak __typeof(self)weakSelf = self;
    CMMotionActivityManager *manager = [[CMMotionActivityManager alloc] init];
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [manager startActivityUpdatesToQueue:queue withHandler:^(CMMotionActivity * _Nullable activity) {
        [manager stopActivityUpdates];
        [weakSelf respondWithState:WTAuthorizationStateAuthorized CompletionBlock:completionBlock];
    }];
}

#pragma mark - 媒體與Apple Music
- (void)requestAccessMediaWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    if ([UIDevice currentDevice].systemVersion.floatValue < 9.3f) {
        [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:completionBlock];
    }
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    
    SKCloudServiceAuthorizationStatus status = [SKCloudServiceController authorizationStatus];
    if (status == SKCloudServiceAuthorizationStatusNotDetermined) {
        
        [SKCloudServiceController requestAuthorization:^(SKCloudServiceAuthorizationStatus status) {
            switch (status) {
                case SKCloudServiceAuthorizationStatusNotDetermined: {
                    wtState = WTAuthorizationStateUnauthorized;
                }
                    break;
                case SKCloudServiceAuthorizationStatusRestricted: {
                }
                    break;
                case SKCloudServiceAuthorizationStatusDenied: {
                    wtState = WTAuthorizationStateDenied;
                }
                    break;
                case SKCloudServiceAuthorizationStatusAuthorized: {
                    wtState = WTAuthorizationStateAuthorized;
                }
                    break;
                default:
                    break;
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == SKCloudServiceAuthorizationStatusRestricted) {
    } else if (status == SKCloudServiceAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else{
        wtState = WTAuthorizationStateAuthorized;
    }

    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - NFC
- (void)requestAccessNFCWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    if ([UIDevice currentDevice].systemVersion.floatValue < 11.0f) {
        [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:completionBlock];
    }
    NFCNDEFReaderSession *session = [[NFCNDEFReaderSession alloc]initWithDelegate:self queue:nil invalidateAfterFirstRead:YES];
    [session beginSession];
    self.NFCCompletionBlock = completionBlock;
}

#pragma mark - NFCNDEFReaderSessionDelegate
- (void)readerSession:(NFCNDEFReaderSession *)session didInvalidateWithError:(NSError *)error {
    [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:self.NFCCompletionBlock];
}

- (void)readerSession:(NFCNDEFReaderSession *)session didDetectNDEFs:(NSArray<NFCNDEFMessage *> *)messages {
        [self respondWithState:WTAuthorizationStateAuthorized CompletionBlock:self.NFCCompletionBlock];
}

#pragma mark - 相冊權(quán)限
- (void)requestAccessPhotosWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    PHAuthorizationStatus status = [PHPhotoLibrary authorizationStatus];
    if (status == PHAuthorizationStatusNotDetermined) {
        [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus status) {
            if (status == PHAuthorizationStatusNotDetermined) {
                wtState = WTAuthorizationStateUnauthorized;
            } else if (status == PHAuthorizationStatusRestricted) {
                
            } else if (status == PHAuthorizationStatusDenied) {
                wtState = WTAuthorizationStateDenied;
            } else {
                wtState = WTAuthorizationStateAuthorized;
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == PHAuthorizationStatusRestricted) {
    } else if (status == PHAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - 提醒事項(xiàng)
- (void)requestAccessRemindersWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    EKAuthorizationStatus status = [EKEventStore authorizationStatusForEntityType:EKEntityTypeReminder];
    
    if (status == EKAuthorizationStatusNotDetermined) {
        EKEventStore *store = [[EKEventStore alloc] init];

        [store requestAccessToEntityType:EKEntityTypeReminder completion:^(BOOL granted, NSError * _Nullable error) {
            if (error) {} else {
                if (granted) {
                    wtState = WTAuthorizationStateAuthorized;
                } else {
                    wtState = WTAuthorizationStateDenied;
                }
            }
            
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == EKAuthorizationStatusRestricted) {
        
    } else if (status == EKAuthorizationStatusDenied) {
       wtState = WTAuthorizationStateDenied;
        
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - Siri
- (void)requestAccessSiriWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    if ([UIDevice currentDevice].systemVersion.floatValue < 10.0f) {
        [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:completionBlock];
    }
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    INSiriAuthorizationStatus status = [INPreferences siriAuthorizationStatus];
    if (status == INSiriAuthorizationStatusNotDetermined) {
        [INPreferences requestSiriAuthorization:^(INSiriAuthorizationStatus status) {
            if (status == INSiriAuthorizationStatusNotDetermined) {
                wtState = WTAuthorizationStateUnauthorized;
            } else if (status == INSiriAuthorizationStatusDenied) {
                wtState = WTAuthorizationStateDenied;
            } else if (status == INSiriAuthorizationStatusAuthorized) {
                wtState = WTAuthorizationStateAuthorized;
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == EKAuthorizationStatusRestricted) {

    } else if (status == EKAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

#pragma mark - 語音識別
- (void)requestAccessSpeechWithCompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    if ([UIDevice currentDevice].systemVersion.floatValue < 10.0f) {
         [self respondWithState:WTAuthorizationStateUnsupported CompletionBlock:completionBlock];
    }
    __weak __typeof(self)weakSelf = self;
    __block WTAuthorizationState wtState = WTAuthorizationStateUnkonw;
    SFSpeechRecognizerAuthorizationStatus status = [SFSpeechRecognizer authorizationStatus];
    
    if (status == SFSpeechRecognizerAuthorizationStatusNotDetermined) {
        [SFSpeechRecognizer requestAuthorization:^(SFSpeechRecognizerAuthorizationStatus status) {
            
            if (status == SFSpeechRecognizerAuthorizationStatusNotDetermined) {
                wtState = WTAuthorizationStateUnauthorized;
                
            } else if (status == SFSpeechRecognizerAuthorizationStatusDenied) {
                wtState = WTAuthorizationStateDenied;
                
            } else if (status == SFSpeechRecognizerAuthorizationStatusAuthorized) {
                wtState = WTAuthorizationStateAuthorized;
            }
            [weakSelf respondWithState:wtState CompletionBlock:completionBlock];
        }];
        return;
    } else if (status == SFSpeechRecognizerAuthorizationStatusDenied) {
        wtState = WTAuthorizationStateDenied;
    } else if (status == SFSpeechRecognizerAuthorizationStatusRestricted) {
        
    } else {
        wtState = WTAuthorizationStateAuthorized;
    }
    [self respondWithState:wtState CompletionBlock:completionBlock];
}

隱私權(quán)限請求完成應(yīng)在主線程中完成回調(diào)

#pragma mark - 在主線程中完成回調(diào)
- (void)respondWithState:(WTAuthorizationState)state CompletionBlock:(AuthorizationStateCompletionBlock)completionBlock {
    dispatch_async(dispatch_get_main_queue(), ^{
        if (completionBlock) {
            completionBlock(state);
        }
    });
}

總結(jié)

獲取隱私權(quán)限需要分為四步：

• 在Info.plist文件中配置應(yīng)用所需權(quán)限方援；
• 在項(xiàng)目的Targets->Capabilities中開啟相應(yīng)開關(guān)，目前Siri涛癌、Health犯戏、NFC、HomeKit需要開啟拳话；
• 引入相關(guān)庫先匪；
• 使用代碼獲取對應(yīng)的隱私權(quán)限。

參考

Protecting the User’s Privacy
Checking and Requesting Access to Data Classes in Privacy Settings