Fix ARC issues (handlers released too soon)

ios/FaceID/RNPermissionHandlerFaceID.m

       return resolve(RNPermissionStatusNotAvailable);
     }
 
-    if (![RNPermissions hasAlreadyBeenRequested:self]) {
+    if (![RNPermissions isFlaggedAsRequested:[[self class] handlerUniqueId]]) {
       return resolve(RNPermissionStatusNotDetermined);
     }
 
                       reply:^(__unused BOOL success, __unused NSError * _Nullable error) {}];
 
     // Hack to invalidate FaceID verification immediately after being requested
-    [self performSelector:@selector(invalidateContext) withObject:self afterDelay:0.015];
+    [self performSelector:@selector(invalidateContext) withObject:self afterDelay:0.05];
   } else {
     resolve(RNPermissionStatusNotAvailable);
   }
                                                   name:UIApplicationDidBecomeActiveNotification
                                                 object:nil];
 
+  [RNPermissions flagAsRequested:[[self class] handlerUniqueId]];
   [self checkWithResolver:_resolve rejecter:_reject];
 }
 

ios/LocationAlways/RNPermissionHandlerLocationAlways.m

   _initialChangeEventFired = false;
   _isWaitingDidBecomeActive = false;
 
-  if (status == kCLAuthorizationStatusAuthorizedWhenInUse && ![RNPermissions hasAlreadyBeenRequested:self]) {
+  if (status == kCLAuthorizationStatusAuthorizedWhenInUse && ![RNPermissions isFlaggedAsRequested:[[self class] handlerUniqueId]]) {
     _isWaitingDidBecomeActive = true;
 
     [[NSNotificationCenter defaultCenter] addObserver:self
 }
 
 - (void)onAuthorizationStatus {
+  [RNPermissions flagAsRequested:[[self class] handlerUniqueId]];
   [self checkWithResolver:_resolve rejecter:_reject];
 
   [_locationManager setDelegate:nil];

ios/Motion/RNPermissionHandlerMotion.m

     }
   }
 
-  if (![RNPermissions hasAlreadyBeenRequested:self]) {
+  if (![RNPermissions isFlaggedAsRequested:[[self class] handlerUniqueId]]) {
     return resolve(RNPermissionStatusNotDetermined);
   }
 
 
     self->_operationQueue = nil;
     self->_activityManager = nil;
+
+    [RNPermissions flagAsRequested:[[self class] handlerUniqueId]];
   }];
 }
 

ios/Notifications/RNPermissionHandlerNotifications.h

 #import "RNPermissions.h"
 
-@interface RNPermissionHandlerNotifications : NSObject<RNPermissionHandler, RNPermissionWithRequestOptions>
+@interface RNPermissionHandlerNotifications : NSObject
 
-- (void)getSettingsWithResolver:(void (^ _Nonnull)(NSDictionary * _Nonnull settings))resolve;
++ (NSString * _Nonnull)handlerUniqueId;
+
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus status, NSDictionary * _Nonnull settings))resolve
+                 rejecter:(void (^ _Nonnull)(NSError * _Nonnull error))reject;
+
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus status, NSDictionary * _Nonnull settings))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull error))reject
+                    options:(NSArray<NSString *> * _Nonnull)options;
 
 @end

ios/Notifications/RNPermissionHandlerNotifications.m

 
 @interface RNPermissionHandlerNotifications()
 
-@property (nonatomic, strong) void (^resolve)(RNPermissionStatus status);
+@property (nonatomic, strong) void (^resolve)(RNPermissionStatus status, NSDictionary * _Nonnull settings);
 @property (nonatomic, strong) void (^reject)(NSError *error);
 
 @end
 
 @implementation RNPermissionHandlerNotifications
 
-+ (NSArray<NSString *> * _Nonnull)usageDescriptionKeys {
-  return @[];
-}
-
 + (NSString * _Nonnull)handlerUniqueId {
   return @"ios.permission.NOTIFICATIONS";
 }
 
-- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
-                 rejecter:(void (__unused ^ _Nonnull)(NSError * _Nonnull))reject {
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus status, NSDictionary * _Nonnull settings))resolve
+                 rejecter:(void (^ _Nonnull)(NSError * _Nonnull error))reject {
   if (@available(iOS 10.0, *)) {
-    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+    [[UNUserNotificationCenter currentNotificationCenter] getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
+      NSMutableDictionary *result = [NSMutableDictionary new];
+
+      bool alert = settings.alertSetting == UNNotificationSettingEnabled;
+      bool badge = settings.badgeSetting == UNNotificationSettingEnabled;
+      bool sound = settings.soundSetting == UNNotificationSettingEnabled;
+      bool lockScreen = settings.lockScreenSetting == UNNotificationSettingEnabled;
+      bool carPlay = settings.carPlaySetting == UNNotificationSettingEnabled;
+
+      if (settings.alertSetting != UNNotificationSettingNotSupported)
+        [result setValue:@(alert) forKey:@"alert"];
+      if (settings.badgeSetting != UNNotificationSettingNotSupported)
+        [result setValue:@(badge) forKey:@"badge"];
+      if (settings.soundSetting != UNNotificationSettingNotSupported)
+        [result setValue:@(sound) forKey:@"sound"];
+      if (settings.lockScreenSetting != UNNotificationSettingNotSupported)
+        [result setValue:@(lockScreen) forKey:@"lockScreen"];
+      if (settings.carPlaySetting != UNNotificationSettingNotSupported)
+        [result setValue:@(carPlay) forKey:@"carPlay"];
+
+      if (@available(iOS 12.0, *)) {
+        bool criticalAlert = settings.criticalAlertSetting == UNNotificationSettingEnabled;
+
+        if (settings.criticalAlertSetting != UNNotificationSettingNotSupported)
+          [result setValue:@(criticalAlert) forKey:@"criticalAlert"];
+      }
 
-    [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
       switch (settings.authorizationStatus) {
         case UNAuthorizationStatusNotDetermined:
 #ifdef __IPHONE_12_0
         case UNAuthorizationStatusProvisional:
 #endif
-          return resolve(RNPermissionStatusNotDetermined);
+          return resolve(RNPermissionStatusNotDetermined, result);
         case UNAuthorizationStatusDenied:
-          return resolve(RNPermissionStatusDenied);
+          return resolve(RNPermissionStatusDenied, result);
         case UNAuthorizationStatusAuthorized:
-          return resolve(RNPermissionStatusAuthorized);
+          return resolve(RNPermissionStatusAuthorized, result);
       }
     }];
   } else {
     UIUserNotificationSettings *settings = [[UIApplication sharedApplication] currentUserNotificationSettings];
+    UIUserNotificationType types = [settings types];
 
-    if ([settings types] != UIUserNotificationTypeNone) {
-      return resolve(RNPermissionStatusAuthorized);
-    } else if ([RNPermissions hasAlreadyBeenRequested:self]) {
-      return resolve(RNPermissionStatusDenied);
+    NSDictionary *result = @{
+      @"alert": @((bool)(types & UIUserNotificationTypeAlert)),
+      @"badge": @((bool)(types & UIUserNotificationTypeBadge)),
+      @"sound": @((bool)(types & UIUserNotificationTypeSound)),
+    };
+
+    if (types != UIUserNotificationTypeNone) {
+      return resolve(RNPermissionStatusAuthorized, result);
+    } else if ([RNPermissions isFlaggedAsRequested:[[self class] handlerUniqueId]]) {
+      return resolve(RNPermissionStatusDenied, result);
     } else {
-      return resolve(RNPermissionStatusNotDetermined);
+      return resolve(RNPermissionStatusNotDetermined, result);
     }
   }
 }
 
-- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
-                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject {
-  NSArray<NSString *> *options = [[NSArray alloc] initWithObjects:@"alert", @"badge", @"sound", nil];
-  [self requestWithResolver:resolve rejecter:reject options:options];
-}
-
-- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
-                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus status, NSDictionary * _Nonnull settings))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull error))reject
                     options:(NSArray<NSString *> * _Nonnull)options {
+  _resolve = resolve;
+  _reject = reject;
+
   bool alert = [options containsObject:@"alert"];
   bool badge = [options containsObject:@"badge"];
   bool sound = [options containsObject:@"sound"];
       types += UNAuthorizationOptionSound;
     }
 
-    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
-
-    [center requestAuthorizationWithOptions:types
-                          completionHandler:^(BOOL granted, NSError * _Nullable error) {
+    [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:types
+                                                                        completionHandler:^(BOOL granted, NSError * _Nullable error) {
       if (error != nil) {
         return reject(error);
       }
+
       if (granted) {
         dispatch_async(dispatch_get_main_queue(), ^{
           [[UIApplication sharedApplication] registerForRemoteNotifications];
         });
       }
 
-      [self checkWithResolver:resolve rejecter:reject];
+      [RNPermissions flagAsRequested:[[self class] handlerUniqueId]];
+      [self checkWithResolver:self->_resolve rejecter:self->_reject];
     }];
   } else {
-    UIUserNotificationType types = UIUserNotificationTypeNone;
-
-    if (alert) types += UIUserNotificationTypeAlert;
-    if (badge) types += UIUserNotificationTypeBadge;
-    if (sound) types += UIUserNotificationTypeSound;
+    if ([RNPermissions isFlaggedAsRequested:[[self class] handlerUniqueId]]) {
+      [self checkWithResolver:_resolve rejecter:_reject];
+    } else {
+      UIUserNotificationType types = UIUserNotificationTypeNone;
 
-    if (!alert && !badge && !sound) {
-      types += UIUserNotificationTypeAlert;
-      types += UIUserNotificationTypeBadge;
-      types += UIUserNotificationTypeSound;
-    }
+      if (alert) types += UIUserNotificationTypeAlert;
+      if (badge) types += UIUserNotificationTypeBadge;
+      if (sound) types += UIUserNotificationTypeSound;
 
-    _resolve = resolve;
-    _reject = reject;
+      if (!alert && !badge && !sound) {
+        types += UIUserNotificationTypeAlert;
+        types += UIUserNotificationTypeBadge;
+        types += UIUserNotificationTypeSound;
+      }
 
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                            selector:@selector(onApplicationDidBecomeActive)
-                                                name:UIApplicationDidBecomeActiveNotification
-                                              object:nil];
+      [[NSNotificationCenter defaultCenter] addObserver:self
+                                               selector:@selector(onApplicationDidBecomeActive)
+                                                   name:UIApplicationDidBecomeActiveNotification
+                                                 object:nil];
 
-    UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:types categories:nil];
-    [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
-    [[UIApplication sharedApplication] registerForRemoteNotifications];
+      UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:types categories:nil];
+      [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
+      [[UIApplication sharedApplication] registerForRemoteNotifications];
+    }
   }
 }
 
                                                   name:UIApplicationDidBecomeActiveNotification
                                                 object:nil];
 
+  [RNPermissions flagAsRequested:[[self class] handlerUniqueId]];
   [self checkWithResolver:_resolve rejecter:_reject];
 }
 
-- (void)getSettingsWithResolver:(void (^ _Nonnull)(NSDictionary * _Nonnull settings))resolve {
-  if (@available(iOS 10.0, *)) {
-    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
-
-    [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
-      NSMutableDictionary *result = [NSMutableDictionary new];
-
-      bool alert = settings.alertSetting == UNNotificationSettingEnabled;
-      bool badge = settings.badgeSetting == UNNotificationSettingEnabled;
-      bool sound = settings.soundSetting == UNNotificationSettingEnabled;
-      bool lockScreen = settings.lockScreenSetting == UNNotificationSettingEnabled;
-      bool carPlay = settings.carPlaySetting == UNNotificationSettingEnabled;
-
-      if (settings.alertSetting != UNNotificationSettingNotSupported)
-        [result setValue:@(alert) forKey:@"alert"];
-      if (settings.badgeSetting != UNNotificationSettingNotSupported)
-        [result setValue:@(badge) forKey:@"badge"];
-      if (settings.soundSetting != UNNotificationSettingNotSupported)
-        [result setValue:@(sound) forKey:@"sound"];
-      if (settings.lockScreenSetting != UNNotificationSettingNotSupported)
-        [result setValue:@(lockScreen) forKey:@"lockScreen"];
-      if (settings.carPlaySetting != UNNotificationSettingNotSupported)
-        [result setValue:@(carPlay) forKey:@"carPlay"];
-
-      if (@available(iOS 12.0, *)) {
-        bool criticalAlert = settings.criticalAlertSetting == UNNotificationSettingEnabled;
-
-        if (settings.criticalAlertSetting != UNNotificationSettingNotSupported)
-          [result setValue:@(criticalAlert) forKey:@"criticalAlert"];
-      }
-
-      resolve(result);
-    }];
-  } else {
-    UIUserNotificationType types = [[[UIApplication sharedApplication] currentUserNotificationSettings] types];
-
-    resolve(@{
-      @"alert": @((bool)(types & UIUserNotificationTypeAlert)),
-      @"badge": @((bool)(types & UIUserNotificationTypeBadge)),
-      @"sound": @((bool)(types & UIUserNotificationTypeSound)),
-    });
-  }
-}
-
 @end

ios/RNPermissions.h

 
 @end
 
-@protocol RNPermissionWithRequestOptions <NSObject>
-
-@required
-
-- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus status))resolve
-                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull error))reject
-                    options:(NSArray<NSString *> * _Nonnull)options;
-
-@end
-
 @interface RNPermissions : NSObject <RCTBridgeModule>
 
-+ (bool)hasAlreadyBeenRequested:(id<RNPermissionHandler> _Nonnull)handler;
++ (bool)isFlaggedAsRequested:(NSString * _Nonnull)handlerId;
+
++ (void)flagAsRequested:(NSString * _Nonnull)handlerId;
 
 + (bool)isBackgroundModeEnabled:(NSString * _Nonnull)mode;
 

ios/RNPermissions.m

   }
 }
 
-+ (void)setRequested:(id<RNPermissionHandler> _Nonnull)handler {
++ (bool)isFlaggedAsRequested:(NSString * _Nonnull)handlerId {
+  NSArray<NSString *> *requested = [[NSUserDefaults standardUserDefaults] arrayForKey:SETTING_KEY];
+  return requested == nil ? false : [requested containsObject:handlerId];
+}
+
++ (void)flagAsRequested:(NSString * _Nonnull)handlerId {
   NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
-  NSString *handlerUniqueId = [[handler class] handlerUniqueId];
   NSMutableArray *requested = [[userDefaults arrayForKey:SETTING_KEY] mutableCopy];
 
   if (requested == nil) {
     requested = [NSMutableArray new];
   }
 
-  if (![requested containsObject:handlerUniqueId]) {
-    [requested addObject:handlerUniqueId];
+  if (![requested containsObject:handlerId]) {
+    [requested addObject:handlerId];
     [userDefaults setObject:requested forKey:SETTING_KEY];
     [userDefaults synchronize];
   }
 }
 
-+ (bool)hasAlreadyBeenRequested:(id<RNPermissionHandler> _Nonnull)handler {
-  NSArray<NSString *> *requested = [[NSUserDefaults standardUserDefaults] arrayForKey:SETTING_KEY];
-  return requested == nil ? false : [requested containsObject:[[handler class] handlerUniqueId]];
-}
-
 + (bool)isBackgroundModeEnabled:(NSString * _Nonnull)mode {
   NSArray *modes = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIBackgroundModes"];
   return [modes isKindOfClass:[NSArray class]] && [modes containsObject:mode];
   id<RNPermissionHandler> handler = [self handlerForPermission:permission];
 
   [handler checkWithResolver:^(RNPermissionStatus status) {
-    resolve([self stringForStatus:status]);
+    NSString *strStatus = [self stringForStatus:status];
+    NSLog(@"[react-native-permissions] %@ permission checked: %@", [[handler class] handlerUniqueId], strStatus);
+    resolve(strStatus);
   } rejecter:^(NSError *error) {
+    NSLog(@"[react-native-permissions] %@ permission failed: %@", [[handler class] handlerUniqueId], error.localizedDescription);
     reject([NSString stringWithFormat:@"%ld", (long)error.code], error.localizedDescription, error);
   }];
 }
   id<RNPermissionHandler> handler = [self handlerForPermission:permission];
 
   [handler requestWithResolver:^(RNPermissionStatus status) {
-    [RNPermissions setRequested:handler];
-    resolve([self stringForStatus:status]);
+    NSString *strStatus = [self stringForStatus:status];
+    NSLog(@"[react-native-permissions] %@ permission checked: %@", [[handler class] handlerUniqueId], strStatus);
+    resolve(strStatus);
   } rejecter:^(NSError *error) {
+    NSLog(@"[react-native-permissions] %@ permission failed: %@", [[handler class] handlerUniqueId], error.localizedDescription);
     reject([NSString stringWithFormat:@"%ld", (long)error.code], error.localizedDescription, error);
   }];
 }
 #if __has_include("RNPermissionHandlerNotifications.h")
   RNPermissionHandlerNotifications *handler = [RNPermissionHandlerNotifications new];
 
-  [handler checkWithResolver:^(RNPermissionStatus status) {
-    [handler getSettingsWithResolver:^(NSDictionary * _Nonnull settings) {
-      resolve(@{ @"status": [self stringForStatus:status], @"settings": settings });
-    }];
+  [handler checkWithResolver:^(RNPermissionStatus status, NSDictionary * _Nonnull settings) {
+    NSString *strStatus = [self stringForStatus:status];
+    NSLog(@"[react-native-permissions] %@ permission checked: %@", [[handler class] handlerUniqueId], strStatus);
+    resolve(@{ @"status": strStatus, @"settings": settings });
   } rejecter:^(NSError * _Nonnull error) {
+    NSLog(@"[react-native-permissions] %@ permission failed: %@", [[handler class] handlerUniqueId], error.localizedDescription);
     reject([NSString stringWithFormat:@"%ld", (long)error.code], error.localizedDescription, error);
   }];
 #else
-  reject(@"notification_missing", @"Notification permission handler is missing", nil);
+  reject(@"notifications_pod_missing", @"Notifications permission pod is missing", nil);
 #endif
 }
 
 #if __has_include("RNPermissionHandlerNotifications.h")
   RNPermissionHandlerNotifications *handler = [RNPermissionHandlerNotifications new];
 
-  [handler requestWithResolver:^(RNPermissionStatus status) {
-    [handler getSettingsWithResolver:^(NSDictionary * _Nonnull settings) {
-      resolve(@{ @"status": [self stringForStatus:status], @"settings": settings });
-    }];
+  [handler requestWithResolver:^(RNPermissionStatus status, NSDictionary * _Nonnull settings) {
+    NSString *strStatus = [self stringForStatus:status];
+    NSLog(@"[react-native-permissions] %@ permission checked: %@", [[handler class] handlerUniqueId], strStatus);
+    resolve(@{ @"status": strStatus, @"settings": settings });
   } rejecter:^(NSError * _Nonnull error) {
+    NSLog(@"[react-native-permissions] %@ permission failed: %@", [[handler class] handlerUniqueId], error.localizedDescription);
     reject([NSString stringWithFormat:@"%ld", (long)error.code], error.localizedDescription, error);
   } options:options];
 #else
-  reject(@"notification_missing", @"Notification permission handler is missing", nil);
+  reject(@"notifications_pod_missing", @"Notifications permission pod is missing", nil);
 #endif
 }