ns-permissions
Version:
Add a plugin description
783 lines • 32.4 kB
JavaScript
import { CLog, CLogTypes } from './common';
export * from './common';
export var PermissionsIOS;
(function (PermissionsIOS) {
let Status;
(function (Status) {
Status["Undetermined"] = "undetermined";
Status["Denied"] = "denied";
Status["Authorized"] = "authorized";
Status["Restricted"] = "restricted";
})(Status = PermissionsIOS.Status || (PermissionsIOS.Status = {}));
let NSPLocation;
(function (NSPLocation) {
let status = Status.Undetermined;
function getStatusFromCLAuthorizationStatus(lStatus, type) {
let always = false;
switch (lStatus) {
case 3 /* kCLAuthorizationStatusAuthorizedAlways */:
always = true;
status = Status.Authorized;
break;
case 4 /* kCLAuthorizationStatusAuthorizedWhenInUse */:
status = Status.Authorized;
break;
case 2 /* kCLAuthorizationStatusDenied */:
status = Status.Denied;
break;
case 1 /* kCLAuthorizationStatusRestricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
CLog(CLogTypes.info, 'NSPLocation getStatusFromCLAuthorizationStatus', lStatus, type, status, always);
return [status, always];
}
function getStatusForType(type) {
const status2 = CLLocationManager.authorizationStatus();
return getStatusFromCLAuthorizationStatus(status2, type);
}
NSPLocation.getStatusForType = getStatusForType;
let locationManager;
let locationManagerDelegate;
class CLLocationManagerDelegateImpl extends NSObject {
addSubDelegate(delegate) {
if (!this.subDelegates) {
this.subDelegates = [];
}
const index = this.subDelegates.indexOf(delegate);
if (index === -1) {
this.subDelegates.push(delegate);
}
}
removeSubDelegate(delegate) {
const index = this.subDelegates.indexOf(delegate);
if (index !== -1) {
this.subDelegates.splice(index, 1);
}
}
static new() {
return super.new();
}
initDelegate() {
this.subDelegates = [];
return this;
}
locationManagerDidChangeAuthorizationStatus(manager, status) {
this.subDelegates &&
this.subDelegates.forEach(d => {
if (d.locationManagerDidChangeAuthorizationStatus) {
d.locationManagerDidChangeAuthorizationStatus(manager, status);
}
});
}
}
CLLocationManagerDelegateImpl.ObjCProtocols = [CLLocationManagerDelegate];
NSPLocation.CLLocationManagerDelegateImpl = CLLocationManagerDelegateImpl;
function request(type) {
const status = getStatusForType(type);
CLog(CLogTypes.info, 'NSPLocation request', type, status);
if (status[0] === Status.Undetermined) {
return new Promise((resolve, reject) => {
if (!locationManager) {
locationManager = CLLocationManager.new();
}
if (!locationManagerDelegate) {
locationManagerDelegate = CLLocationManagerDelegateImpl.new().initDelegate();
locationManager.delegate = locationManagerDelegate;
}
const subD = {
locationManagerDidChangeAuthorizationStatus: (manager, status) => {
CLog(CLogTypes.info, 'locationManagerDidChangeAuthorizationStatus', status);
if (status !== 0 /* kCLAuthorizationStatusNotDetermined */) {
if (locationManagerDelegate) {
locationManagerDelegate.removeSubDelegate(subD);
locationManagerDelegate = null;
}
if (locationManager) {
locationManager.delegate = null;
locationManager = null;
}
const rStatus = getStatusFromCLAuthorizationStatus(status, type);
resolve(rStatus);
// } else {
// reject('kCLAuthorizationStatusNotDetermined');
}
}
};
locationManagerDelegate.addSubDelegate(subD);
try {
CLog(CLogTypes.info, 'NSPLocation requestAuthorization', type);
if (type === 'always') {
locationManager.requestAlwaysAuthorization();
}
else {
locationManager.requestWhenInUseAuthorization();
}
}
catch (e) {
reject(e);
if (locationManagerDelegate) {
locationManagerDelegate.removeSubDelegate(subD);
locationManagerDelegate = null;
}
if (locationManager) {
locationManager.delegate = null;
locationManager = null;
}
}
});
}
else {
// if (CLLocationManager.authorizationStatus() === CLAuthorizationStatus.kCLAuthorizationStatusAuthorizedWhenInUse && type === 'always') {
// return Promise.resolve(Status.Denied);
// } else {
return Promise.resolve(status);
// }
}
}
NSPLocation.request = request;
})(NSPLocation || (NSPLocation = {}));
let NSPBluetooth;
(function (NSPBluetooth) {
let status = Status.Undetermined;
function getStatus() {
const status2 = CBPeripheralManager.authorizationStatus();
switch (status2) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPBluetooth.getStatus = getStatus;
class CBPeripheralManagerDelegateImpl extends NSObject {
addSubDelegate(delegate) {
const index = this.subDelegates.indexOf(delegate);
if (index === -1) {
this.subDelegates.push(delegate);
}
}
removeSubDelegate(delegate) {
const index = this.subDelegates.indexOf(delegate);
if (index !== -1) {
this.subDelegates.splice(index, 1);
}
}
static new() {
return super.new();
}
initDelegate() {
this.subDelegates = [];
return this;
}
peripheralManagerDidUpdateState(peripheralManager) {
this.subDelegates.forEach(d => {
if (d.peripheralManagerDidUpdateState) {
d.peripheralManagerDidUpdateState(peripheralManager);
}
});
}
}
CBPeripheralManagerDelegateImpl.ObjCProtocols = [CBPeripheralManagerDelegate];
NSPBluetooth.CBPeripheralManagerDelegateImpl = CBPeripheralManagerDelegateImpl;
let peripheralManager;
function request() {
const status = getStatus();
if (status[0] === Status.Undetermined) {
return new Promise((resolve, reject) => {
if (!peripheralManager) {
peripheralManager = CBPeripheralManager.new();
peripheralManager.delegate = CBPeripheralManagerDelegateImpl.new().initDelegate();
}
const subD = {
peripheralManagerDidUpdateState: peripheralManager => {
if (peripheralManager) {
peripheralManager.stopAdvertising();
peripheralManager.delegate.removeSubDelegate(subD);
peripheralManager.delegate = null;
peripheralManager = null;
}
// for some reason, checking permission right away returns denied. need to wait a tiny bit
setTimeout(() => {
resolve(getStatus());
}, 100);
}
};
peripheralManager.delegate.addSubDelegate(subD);
try {
peripheralManager.startAdvertising(null);
}
catch (e) {
reject(e);
}
});
}
else {
return Promise.resolve(status);
}
}
NSPBluetooth.request = request;
})(NSPBluetooth || (NSPBluetooth = {}));
let NSPAudioVideo;
(function (NSPAudioVideo) {
let status = Status.Undetermined;
function typeFromString(value) {
if (value === 'audio') {
return AVMediaTypeAudio;
}
else {
return AVMediaTypeVideo;
}
}
function getStatus(type) {
const videoStatus = AVCaptureDevice.authorizationStatusForMediaType(typeFromString(type));
switch (videoStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPAudioVideo.getStatus = getStatus;
function request(type) {
return new Promise((resolve, reject) => {
AVCaptureDevice.requestAccessForMediaTypeCompletionHandler(typeFromString(type), granted => resolve(getStatus(type)));
});
}
NSPAudioVideo.request = request;
})(NSPAudioVideo || (NSPAudioVideo = {}));
let NSPSpeechRecognition;
(function (NSPSpeechRecognition) {
let status = Status.Undetermined;
function getStatus() {
const speechStatus = SFSpeechRecognizer.authorizationStatus();
switch (speechStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 1 /* Denied */:
status = Status.Denied;
break;
case 2 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPSpeechRecognition.getStatus = getStatus;
function request() {
return new Promise(resolve => {
SFSpeechRecognizer.requestAuthorization(() => resolve(getStatus()));
});
}
NSPSpeechRecognition.request = request;
})(NSPSpeechRecognition || (NSPSpeechRecognition = {}));
let NSPPhoto;
(function (NSPPhoto) {
let status = Status.Undetermined;
function getStatus() {
const photoStatus = PHPhotoLibrary.authorizationStatus();
switch (photoStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPPhoto.getStatus = getStatus;
function request() {
return new Promise(resolve => {
PHPhotoLibrary.requestAuthorization(() => resolve(getStatus()));
});
}
NSPPhoto.request = request;
})(NSPPhoto || (NSPPhoto = {}));
let NSPMotion;
(function (NSPMotion) {
let status = Status.Undetermined;
function getStatus() {
if (status === Status.Undetermined) {
const cmStatus = CMMotionActivityManager.authorizationStatus;
switch (cmStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
}
}
return [status, true];
}
NSPMotion.getStatus = getStatus;
function request() {
if (status === Status.Undetermined) {
return new Promise(resolve => {
let activityManager = CMMotionActivityManager.new();
let motionActivityQueue = NSOperationQueue.new();
CLog(CLogTypes.info, 'NSPMotion request', status);
activityManager.queryActivityStartingFromDateToDateToQueueWithHandler(NSDate.distantPast, new Date(), motionActivityQueue, (activities, error) => {
if (error) {
status = Status.Denied;
}
else if (activities || !error) {
status = Status.Authorized;
}
CLog(CLogTypes.info, 'NSPMotion got response', activities, error, status, getStatus());
resolve([status, true]);
activityManager = null;
motionActivityQueue = null;
});
});
}
else {
return Promise.resolve([status, true]);
}
}
NSPMotion.request = request;
})(NSPMotion || (NSPMotion = {}));
let NSPMediaLibrary;
(function (NSPMediaLibrary) {
let status = Status.Undetermined;
function getStatus() {
const mediaStatus = MPMediaLibrary.authorizationStatus();
switch (mediaStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 1 /* Denied */:
status = Status.Denied;
break;
case 2 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPMediaLibrary.getStatus = getStatus;
function request() {
return new Promise(resolve => {
MPMediaLibrary.requestAuthorization(() => resolve(getStatus()));
});
}
NSPMediaLibrary.request = request;
})(NSPMediaLibrary || (NSPMediaLibrary = {}));
let NSPNotification;
(function (NSPNotification) {
let status = Status.Undetermined;
const NSPDidAskForNotification = 'NSPDidAskForNotification';
function getStatus() {
const didAskForPermission = NSUserDefaults.standardUserDefaults.boolForKey(NSPDidAskForNotification);
const isEnabled = UIApplication.sharedApplication.currentUserNotificationSettings.types !== 0 /* None */;
if (isEnabled) {
status = Status.Authorized;
}
else {
status = didAskForPermission ? Status.Denied : Status.Undetermined;
}
return [status, true];
}
NSPNotification.getStatus = getStatus;
function request(types) {
const status = getStatus();
if (status[0] === Status.Undetermined) {
return new Promise(resolve => {
const observer = function () {
resolve(getStatus());
NSNotificationCenter.defaultCenter.removeObserver(observer);
};
NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(UIApplicationDidBecomeActiveNotification, null, null, observer);
const settings = UIUserNotificationSettings.settingsForTypesCategories(types, null);
UIApplication.sharedApplication.registerUserNotificationSettings(settings);
UIApplication.sharedApplication.registerForRemoteNotifications();
NSUserDefaults.standardUserDefaults.setBoolForKey(true, NSPDidAskForNotification);
NSUserDefaults.standardUserDefaults.synchronize();
});
}
else {
return Promise.resolve(status);
}
}
NSPNotification.request = request;
})(NSPNotification || (NSPNotification = {}));
let NSPContacts;
(function (NSPContacts) {
let status = Status.Undetermined;
function getStatus() {
const contactStatus = CNContactStore.authorizationStatusForEntityType(0 /* Contacts */);
switch (contactStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPContacts.getStatus = getStatus;
function request() {
return new Promise(resolve => {
const contactStore = CNContactStore.new();
contactStore.requestAccessForEntityTypeCompletionHandler(0 /* Contacts */, () => resolve(getStatus()));
});
}
NSPContacts.request = request;
})(NSPContacts || (NSPContacts = {}));
let NSPBackgroundRefresh;
(function (NSPBackgroundRefresh) {
let status = Status.Undetermined;
function getStatus() {
const refreshStatus = UIApplication.sharedApplication.backgroundRefreshStatus;
switch (refreshStatus) {
case 2 /* Available */:
status = Status.Authorized;
break;
case 1 /* Denied */:
status = Status.Denied;
break;
case 0 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPBackgroundRefresh.getStatus = getStatus;
function request() {
return new Promise(resolve => {
const contactStore = CNContactStore.new();
contactStore.requestAccessForEntityTypeCompletionHandler(0 /* Contacts */, () => resolve(getStatus()[0]));
});
}
NSPBackgroundRefresh.request = request;
})(NSPBackgroundRefresh || (NSPBackgroundRefresh = {}));
let NSPEvent;
(function (NSPEvent) {
let status = Status.Undetermined;
function typeFromString(value) {
if (value === 'reminder') {
return 1 /* Reminder */;
}
else {
return 0 /* Event */;
}
}
function getStatus(type) {
const eventStatus = EKEventStore.authorizationStatusForEntityType(typeFromString(type));
switch (eventStatus) {
case 3 /* Authorized */:
status = Status.Authorized;
break;
case 2 /* Denied */:
status = Status.Denied;
break;
case 1 /* Restricted */:
status = Status.Restricted;
break;
default:
status = Status.Undetermined;
}
return [status, true];
}
NSPEvent.getStatus = getStatus;
function request(type) {
return new Promise(resolve => {
const aStore = EKEventStore.new();
aStore.requestAccessToEntityTypeCompletion(typeFromString(type), () => resolve(getStatus(type)));
});
}
NSPEvent.request = request;
})(NSPEvent || (NSPEvent = {}));
let NSType;
(function (NSType) {
NSType[NSType["Unknown"] = 0] = "Unknown";
NSType["Location"] = "location";
NSType["Camera"] = "camera";
NSType["Microphone"] = "microphone";
NSType["Photo"] = "photo";
NSType["Contacts"] = "contacts";
NSType["Event"] = "event";
NSType["Reminder"] = "reminder";
NSType["Bluetooth"] = "bluetooth";
NSType["Notification"] = "notification";
NSType["BackgroundRefresh"] = "backgroundRefresh";
NSType["NSPTypeSpeechRecognition"] = "speechRecognition";
NSType["MediaLibrary"] = "mediaLibrary";
NSType["Motion"] = "motion";
})(NSType = PermissionsIOS.NSType || (PermissionsIOS.NSType = {}));
function openSettings() {
return new Promise((resolve, reject) => {
const center = NSNotificationCenter.defaultCenter;
const observer = function (notif) {
resolve(true);
center.removeObserver(observer);
};
center.addObserverForNameObjectQueueUsingBlock(UIApplicationDidBecomeActiveNotification, null, null, observer);
UIApplication.sharedApplication.openURL(NSURL.URLWithString(UIApplicationOpenSettingsURLString));
});
}
PermissionsIOS.openSettings = openSettings;
function canOpenSettings() {
return Promise.resolve(UIApplicationOpenSettingsURLString !== null);
}
PermissionsIOS.canOpenSettings = canOpenSettings;
function getPermissionStatus(type, json) {
let status;
CLog(CLogTypes.info, `ns-permissions getPermissionStatus ${type} ${json}`);
switch (type) {
case NSType.Location: {
// NSString *locationPermissionType = [RCTConvert NSString:json];
status = NSPLocation.getStatusForType(json);
break;
}
case NSType.Camera:
status = NSPAudioVideo.getStatus('video');
break;
case NSType.Microphone:
status = NSPAudioVideo.getStatus('audio');
break;
case NSType.Photo:
status = NSPPhoto.getStatus();
break;
case NSType.Contacts:
status = NSPContacts.getStatus();
break;
case NSType.Event:
status = NSPEvent.getStatus('event');
break;
case NSType.Reminder:
status = NSPEvent.getStatus('reminder');
break;
case NSType.Bluetooth:
status = NSPBluetooth.getStatus();
break;
case NSType.Notification:
status = NSPNotification.getStatus();
break;
case NSType.BackgroundRefresh:
status = NSPBackgroundRefresh.getStatus();
break;
case NSType.NSPTypeSpeechRecognition:
status = NSPSpeechRecognition.getStatus();
break;
case NSType.MediaLibrary:
status = NSPMediaLibrary.getStatus();
break;
case NSType.Motion:
status = NSPMotion.getStatus();
break;
default:
break;
}
return Promise.resolve(status);
}
PermissionsIOS.getPermissionStatus = getPermissionStatus;
function getPermissionStatusSync(type, json) {
let status;
CLog(CLogTypes.info, `ns-permissions getPermissionStatus ${type} ${json}`);
switch (type) {
case NSType.Location: {
// NSString *locationPermissionType = [RCTConvert NSString:json];
status = NSPLocation.getStatusForType(json);
break;
}
case NSType.Camera:
status = NSPAudioVideo.getStatus('video');
break;
case NSType.Microphone:
status = NSPAudioVideo.getStatus('audio');
break;
case NSType.Photo:
status = NSPPhoto.getStatus();
break;
case NSType.Contacts:
status = NSPContacts.getStatus();
break;
case NSType.Event:
status = NSPEvent.getStatus('event');
break;
case NSType.Reminder:
status = NSPEvent.getStatus('reminder');
break;
case NSType.Bluetooth:
status = NSPBluetooth.getStatus();
break;
case NSType.Notification:
status = NSPNotification.getStatus();
break;
case NSType.BackgroundRefresh:
status = NSPBackgroundRefresh.getStatus();
break;
case NSType.NSPTypeSpeechRecognition:
status = NSPSpeechRecognition.getStatus();
break;
case NSType.MediaLibrary:
status = NSPMediaLibrary.getStatus();
break;
case NSType.Motion:
status = NSPMotion.getStatus();
break;
default:
break;
}
return status && status[1];
}
PermissionsIOS.getPermissionStatusSync = getPermissionStatusSync;
function requestPermission(type, json) {
CLog(CLogTypes.info, `ns-permissions requestPermission ${type} ${json}`);
switch (type) {
case NSType.Location:
return NSPLocation.request(json);
case NSType.Camera:
return NSPAudioVideo.request('video');
case NSType.Microphone:
return NSPAudioVideo.request('audio');
case NSType.Photo:
return NSPPhoto.request();
case NSType.Contacts:
return NSPContacts.request();
case NSType.Event:
return NSPEvent.request('event');
case NSType.Reminder:
return NSPEvent.request('reminder');
case NSType.Bluetooth:
return NSPBluetooth.request();
case NSType.Notification:
let types;
const typeStrings = json;
if (typeStrings.indexOf('alert') !== -1) {
types = types | 4 /* Alert */;
}
if (typeStrings.indexOf('badge') !== -1) {
types = types | 1 /* Badge */;
}
if (typeStrings.indexOf('sound') !== -1) {
types = types | 2 /* Sound */;
}
return NSPNotification.request(types);
case NSType.NSPTypeSpeechRecognition:
return NSPSpeechRecognition.request();
case NSType.MediaLibrary:
return NSPMediaLibrary.request();
case NSType.Motion:
return NSPMotion.request();
default:
return Promise.reject(NSType.Unknown);
}
}
PermissionsIOS.requestPermission = requestPermission;
})(PermissionsIOS || (PermissionsIOS = {}));
const DEFAULTS = {
location: 'whenInUse',
notification: ['alert', 'badge', 'sound']
};
const permissionTypes = Object.keys(PermissionsIOS.NSType).map(k => PermissionsIOS.NSType[k]);
export function canOpenSettings() {
return PermissionsIOS.canOpenSettings();
}
export function openSettings() {
return PermissionsIOS.openSettings();
}
export function getTypes() {
return permissionTypes;
}
export function hasPermission(permission) {
CLog(CLogTypes.info, `nativescript-perms: check ${permission}`);
if (permissionTypes.indexOf(permission) === -1) {
// const error = new Error(`ReactNativePermissions: ${permission} is not a valid permission type on iOS`);
// return Promise.reject(error);
CLog(CLogTypes.warning, `nativescript-perms: ${permission} is not a valid permission type on iOS`);
// const error = new Error(`nativescript-perms: ${permission} is not a valid permission type on Android`);
return true;
}
return PermissionsIOS.getPermissionStatusSync(permission, DEFAULTS[permission]);
}
export function check(permission, options) {
CLog(CLogTypes.info, `ns-permissions check ${permission} ${options}`);
if (permissionTypes.indexOf(permission) === -1) {
CLog(CLogTypes.warning, `ns-permissions ${permission} is not a valid permission type on iOS`);
return Promise.resolve([PermissionsIOS.Status.Authorized, true]);
}
let type;
if (typeof options === 'string') {
type = options;
}
else if (options && options.type) {
type = options.type;
}
return PermissionsIOS.getPermissionStatus(permission, type || DEFAULTS[permission]);
}
export function request(permission, options) {
CLog(CLogTypes.info, `ns-permissions request ${permission} ${options}`);
if (permissionTypes.indexOf(permission) === -1) {
CLog(CLogTypes.warning, `ns-permissions ${permission} is not a valid permission type on iOS`);
return Promise.resolve([PermissionsIOS.Status.Authorized, true]);
}
if (permission === 'backgroundRefresh') {
const error = new Error('ns-permissions You cannot request backgroundRefresh');
return Promise.reject(error);
}
let type;
if (typeof options === 'string') {
type = options;
}
else if (options && options.type) {
type = options.type;
}
return PermissionsIOS.requestPermission(permission, type || DEFAULTS[permission]);
}
export function requestPermissions(permissions) {
return Promise.all(permissions.map(permission => this.request(permission))).then((result) => result.reduce((acc, value, index) => {
const name = permissions[index];
acc[name] = value;
return acc;
}, {}));
}
export function checkPermissions(permissions) {
return Promise.all(permissions.map(permission => check(permission))).then(result => result.reduce((acc, value, index) => {
const name = permissions[index];
acc[name] = value;
return acc;
}, {}));
}
//# sourceMappingURL=index.ios.js.map