Building Secure Flutter Apps: Using permission_handler Package

Building secure Flutter apps involves properly managing permissions to ensure that users’ data remains protected. Flutter provides many ways to handle permissions, but one of the most popular and versatile packages for managing permissions is permission_handler. In this article, we'll explore how to use permission_handler to handle permissions in a secure way and create a dedicated file to manage these permissions, including error handling. This approach will help ensure that permissions are handled consistently throughout your project.

Getting Started with permission_handler

To get started, add the permission_handler package to your Flutter project's pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  permission_handler: ^11.3.1

After adding it, run flutter pub get to fetch the package.

Why Handle Permissions Securely?

Permissions are a critical part of app security. Improper handling of permissions can lead to vulnerabilities, such as unauthorized access to sensitive data like contacts, location, or camera. Ensuring users understand why a permission is needed helps to build trust and transparency, which in turn improves the user experience.

The permission_handler package provides a simple way to manage permissions, allowing you to check, request, and manage the state of different permissions like location, camera, storage, and more.

Creating a Permission Handler File

To keep your code clean and organized, it is a good practice to centralize all permission-related code in a dedicated file. This helps ensure that permissions are managed consistently and makes it easier to maintain your app in the future.

Below, we’ll create a permission_handler.dart file that contains all the necessary logic for managing permissions, including handling errors.

Step 1: Create a New File for Permission Handling

Create a new Dart file in your project, for example: lib/utils/permission_handler.dart.

Step 2: Write the Permission Handling Code

In permission_handler.dart, we will write functions to handle various permissions, including proper error handling to make the app more robust.

import 'package:permission_handler/permission_handler.dart';

class AppPermissionHandler {
  /// Requests permission for a given [Permission] type.
  /// Returns true if permission is granted, false otherwise.
  static Future<bool> requestPermission(Permission permission) async {
    try {
      final status = await permission.request();
      return status == PermissionStatus.granted;
    } catch (e) {
      // Handle any unexpected errors
      print('Error requesting permission: $e');
      return false;
    }
  }
  /// Checks if a given [Permission] is granted.
  static Future<bool> checkPermission(Permission permission) async {
    try {
      final status = await permission.status;
      return status == PermissionStatus.granted;
    } catch (e) {
      // Handle any unexpected errors
      print('Error checking permission: $e');
      return false;
    }
  }
  /// Requests multiple permissions and returns a map of their statuses.
  static Future<Map<Permission, PermissionStatus>> requestMultiplePermissions(
      List<Permission> permissions) async {
    try {
      final statuses = await permissions.request();
      return statuses;
    } catch (e) {
      // Handle any unexpected errors
      print('Error requesting multiple permissions: $e');
      return {};
    }
  }
  /// Handles permission denial gracefully by showing an alert or navigating to settings.
  static Future<void> handlePermissionDenied(Permission permission) async {
    final status = await permission.status;
    if (status.isDenied || status.isPermanentlyDenied) {
      // Provide the user with instructions on how to grant the permission
      print('Permission denied. Please enable it from app settings.');
    }
  }
}

Integrating Permission Handling in Your App

Now that we have a centralized permission handler file, we can easily use it in our Flutter app. Below is an example of how to integrate the permission handler into a widget.

import 'package:flutter/material.dart';
import 'package:your_project/utils/permission_handler.dart';
import 'package:permission_handler/permission_handler.dart';


class CameraAccessPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Camera Access')),
      body: Center(
        child: ElevatedButton(
          onPressed: () async {
            final isGranted = await AppPermissionHandler.requestPermission(Permission.camera);
            if (isGranted) {
              // Permission granted, proceed to open the camera
              print('Camera permission granted');
            } else {
              // Permission denied, handle accordingly
              await AppPermissionHandler.handlePermissionDenied(Permission.camera);
            }
          },
          child: Text('Request Camera Permission'),
        ),
      ),
    );
  }
}

Handling Edge Cases and Errors

When working with permissions, there are several scenarios to consider:

1. Permissions Denied Permanently: If a user denies a permission permanently, they must be directed to the app settings to enable it manually. The handlePermissionDenied() function in our handler file provides a way to prompt users to do this.
2. Limited Permissions: On some devices, permissions can be granted on a temporary or limited basis. Always check the current permission status before performing sensitive actions.
3. Error Handling: It’s essential to handle unexpected errors, such as exceptions thrown while requesting permissions. Our centralized permission handler file ensures that any errors are logged and managed effectively, providing a more consistent user experience.

Best Practices for Secure Permission Handling

1. Request Permissions Only When Needed: Avoid requesting permissions at the app launch. Instead, request permissions at the point where they are needed, such as when a user tries to access the camera or their location.
2. Explain Why Permissions Are Needed: Always provide users with a clear explanation of why a permission is needed. This builds trust and reduces the likelihood of users denying permissions.
3. Handle Denials Gracefully: Always handle permission denials gracefully. Explain the consequences of not granting the permission and, if possible, provide alternative ways for users to interact with your app.

Conclusion

Managing permissions securely and effectively is a critical part of building a robust Flutter app. The permission_handler package offers a powerful set of tools to simplify permission management, ensuring your app provides a secure experience for users. By using a dedicated permission handler file, you can centralize all permission logic, making your code easier to maintain and reducing the risk of inconsistencies.

Try integrating a centralized permission handler into your project and follow best practices to ensure that your app remains secure and user-friendly. Proper permission handling helps protect user data while improving the overall user experience.