or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/npm-unimodules-permissions-interface

An interface for permissions modules that provides standardized permission status types and platform-specific native interfaces for React Native and Expo applications

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/unimodules-permissions-interface@6.2.x

To install, run

npx @tessl/cli install tessl/npm-unimodules-permissions-interface@6.2.0

index.mddocs/

Unimodules Permissions Interface

The unimodules-permissions-interface package provides a standardized interface for handling permissions across React Native and Expo applications. It defines TypeScript types and enums for permission status management, and provides native platform interfaces for iOS and Android implementations to ensure consistent permission handling across platforms.

Package Information

  • Package Name: unimodules-permissions-interface
  • Package Type: npm
  • Language: TypeScript with Native Platform Interfaces
  • Installation: npm install unimodules-permissions-interface

Core Imports

import { PermissionStatus, PermissionResponse, PermissionExpiration } from "unimodules-permissions-interface";

For CommonJS:

const { PermissionStatus, PermissionResponse, PermissionExpiration } = require("unimodules-permissions-interface");

Basic Usage

import { PermissionStatus, PermissionResponse } from "unimodules-permissions-interface";

// Example permission response
const permissionResponse: PermissionResponse = {
  status: PermissionStatus.GRANTED,
  expires: "never",
  granted: true,
  canAskAgain: false
};

// Check permission status
if (permissionResponse.status === PermissionStatus.GRANTED) {
  console.log("Permission granted");
} else if (permissionResponse.status === PermissionStatus.DENIED) {
  console.log("Permission denied");
} else {
  console.log("Permission undetermined");
}

Capabilities

Permission Status Management

Defines standardized permission states for cross-platform consistency.

enum PermissionStatus {
  GRANTED = 'granted',
  UNDETERMINED = 'undetermined',
  DENIED = 'denied',
}

The PermissionStatus enum provides three possible states:

  • GRANTED: Permission has been explicitly granted by the user
  • UNDETERMINED: Permission has not been requested yet or status is unknown
  • DENIED: Permission has been explicitly denied by the user

Permission Response Structure

Standardized response object for permission requests across platforms.

interface PermissionResponse {
  status: PermissionStatus;
  expires: PermissionExpiration;
  granted: boolean;
  canAskAgain: boolean;
}

Properties:

  • status: Current permission status using PermissionStatus enum
  • expires: When the permission expires (either 'never' or timestamp)
  • granted: Boolean indicating if permission is currently granted
  • canAskAgain: Boolean indicating if the user can be prompted again

Permission Expiration

Defines when a permission expires.

type PermissionExpiration = 'never' | number;

Values:

  • 'never': Permission does not expire
  • number: Unix timestamp when permission expires

Native Platform Interfaces

This package provides native interfaces for platform-specific implementations. These are typically used by native modules and not directly by JavaScript/TypeScript code.

Android Interface (Java)

The Android interface provides methods for permission management:

public interface Permissions {
  // Get permission status asynchronously
  void getPermissionsWithPromise(final Promise promise, String... permissions);
  
  // Request permissions asynchronously
  void askForPermissionsWithPromise(final Promise promise, String... permissions);
  
  // Get permission status with callback
  void getPermissions(final PermissionsResponseListener response, String... permissions);
  
  // Request permissions with callback
  void askForPermissions(final PermissionsResponseListener response, String... permissions);
  
  // Check if permissions are granted (synchronous)
  boolean hasGrantedPermissions(String... permissions);
  
  // Check if permission is declared in AndroidManifest
  boolean isPermissionPresentInManifest(String permission);
}

Static Helper Methods:

// Helper to get permissions with null checking
static void getPermissionsWithPermissionsManager(
  Permissions permissionsManager, 
  final Promise promise, 
  String... permissions
);

// Helper to request permissions with null checking
static void askForPermissionsWithPermissionsManager(
  Permissions permissionsManager, 
  final Promise promise, 
  String... permissions
);

Android Permission Status Enum

public enum PermissionsStatus {
  GRANTED("granted"),
  UNDETERMINED("undetermined"),
  DENIED("denied");
  
  public String getStatus();
}

Android Response Callback

@FunctionalInterface
public interface PermissionsResponseListener {
  void onResult(Map<String, PermissionsResponse> result);
}

Android Response Data Class (Kotlin)

data class PermissionsResponse(
  val status: PermissionsStatus,
  val canAskAgain: Boolean = true
)

Constants available:

  • STATUS_KEY = "status"
  • GRANTED_KEY = "granted"
  • EXPIRES_KEY = "expires"
  • CAN_ASK_AGAIN_KEY = "canAskAgain"
  • SCOPE_KEY = "scope"
  • PERMISSION_EXPIRES_NEVER = "never"
  • SCOPE_IN_USE = "whenInUse"
  • SCOPE_ALWAYS = "always"
  • SCOPE_NONE = "none"

iOS Interface (Objective-C)

The iOS interface provides protocols for permission management:

// Permission status enum
typedef enum UMPermissionStatus {
  UMPermissionStatusDenied,
  UMPermissionStatusGranted,
  UMPermissionStatusUndetermined,
} UMPermissionStatus;

// Protocol for permission requesters
@protocol UMPermissionsRequester <NSObject>
+ (NSString *)permissionType;
- (void)requestPermissionsWithResolver:(UMPromiseResolveBlock)resolve 
                              rejecter:(UMPromiseRejectBlock)reject;
- (NSDictionary *)getPermissions;
@end

// Main permissions interface
@protocol UMPermissionsInterface
- (void)registerRequesters:(NSArray<id<UMPermissionsRequester>> *)newRequesters;

- (void)getPermissionUsingRequesterClass:(Class)requesterClass
                                 resolve:(UMPromiseResolveBlock)resolve
                                  reject:(UMPromiseRejectBlock)reject;

- (BOOL)hasGrantedPermissionUsingRequesterClass:(Class)requesterClass;

- (void)askForPermissionUsingRequesterClass:(Class)requesterClass
                                    resolve:(UMPromiseResolveBlock)resolve
                                     reject:(UMPromiseRejectBlock)reject;

- (id<UMPermissionsRequester>)getPermissionRequesterForType:(NSString *)type;
@end

iOS Helper Delegate

@interface UMPermissionsMethodsDelegate : NSObject

+ (void)getPermissionWithPermissionsManager:(id<UMPermissionsInterface>)permissionsManager
                              withRequester:(Class)requesterClass
                                    resolve:(UMPromiseResolveBlock)resolve
                                     reject:(UMPromiseRejectBlock)reject;

+ (void)askForPermissionWithPermissionsManager:(id<UMPermissionsInterface>)permissionsManager
                                 withRequester:(Class)requesterClass
                                       resolve:(UMPromiseResolveBlock)resolve
                                        reject:(UMPromiseRejectBlock)reject;

+ (void)registerRequesters:(NSArray<id<UMPermissionsRequester>> *)newRequesters
    withPermissionsManager:(id<UMPermissionsInterface>)permissionsManager;

@end

iOS User Notification Center Proxy

@protocol UMUserNotificationCenterProxyInterface <NSObject>

- (void)getNotificationSettingsWithCompletionHandler:(nonnull void(^)(UNNotificationSettings *__nonnull settings))completionHandler;

- (void)requestAuthorizationWithOptions:(UNAuthorizationOptions)options 
                      completionHandler:(nonnull void (^)(BOOL granted, NSError *__nullable error))completionHandler;

@end

Implementation Notes

This package serves as an interface specification - it defines the contracts that concrete permission implementations must follow. Native modules implementing specific permissions (camera, location, notifications, etc.) should extend these interfaces to provide actual permission handling functionality.

The TypeScript types ensure consistent JavaScript API across all permission modules, while the native interfaces ensure consistent platform-specific implementations. This architecture allows Expo and React Native applications to handle permissions uniformly regardless of the specific permission type or platform.