Flutter: Prevent Repeated Permission Requests When Using System Folder Picker

Optimizing Folder Picker Permissions in Flutter

Managing permissions while working with the System Folder Picker in Flutter can be tricky. A common frustration arises when users are repeatedly asked for permissions, even for folders they have previously approved. This issue can disrupt the user experience, especially when dealing with frequently accessed folders. 📂

Imagine a scenario where you want to save a document in a specific folder. You grant permission to the app, but each time you revisit that folder, you are asked for permission again. This redundant flow not only adds unnecessary steps but also makes the process less efficient. Thankfully, Android's Storage Access Framework (SAF) provides tools to optimize this experience.

In this guide, we’ll explore a solution that eliminates repeated permission requests while ensuring users can still switch folders seamlessly. The goal is to remember permissions for approved folders while allowing users to pick new ones whenever needed. By implementing this, your app will provide a smoother, hassle-free workflow. 🚀

Whether you're a developer working on a document management app or simply trying to improve folder selection efficiency, this approach can save time and enhance user satisfaction. Let’s dive into how you can achieve this using Kotlin and Flutter Method Channels, without relying on SharedPreferences.

Streamlining Folder Picker Permissions in Flutter

The scripts provided solve the issue of repeated permission requests when using the System Folder Picker in an Android Flutter application. On the backend, the Kotlin code uses the Storage Access Framework (SAF) to grant and persist access permissions for selected folders. This ensures that users are only asked for permissions when they select a new folder. By leveraging the Intent.ACTION_OPEN_DOCUMENT_TREE command, the folder picker interface is opened, allowing users to choose a directory efficiently. Additionally, the takePersistableUriPermission method is used to retain these permissions across app sessions and even device restarts. This removes the need for SharedPreferences and provides a more robust solution.

The Flutter frontend integrates seamlessly with the Kotlin backend through a MethodChannel. This channel acts as a bridge, enabling communication between the Dart and Kotlin layers. When a user clicks the "Pick Folder" button in the Flutter UI, a method call is sent to the backend to either fetch the saved URI or launch the folder picker if no URI exists. If the user selects a new folder, the backend saves its URI and persists permissions for future use. The frontend then dynamically updates the UI to reflect the selected folder, ensuring a user-friendly experience. 📂

One of the most important aspects of this implementation is error handling. For example, if a folder selection fails or the user cancels the picker, the app gracefully notifies the user via error messages displayed in the Flutter UI. This ensures the application remains resilient and easy to use. A practical example could be a document manager app where users often save files to specific folders. By persisting permissions for these folders, users avoid repetitive prompts and save time when navigating the app. 🚀

In summary, the scripts are designed to optimize the folder selection workflow in Android Flutter applications. The backend handles the complex logic of managing folder URIs and permissions, while the frontend ensures a smooth user experience through clear interaction flows. By following these techniques, developers can improve their apps' efficiency and user satisfaction, making them better equipped for scenarios involving frequent file storage and folder navigation. This approach demonstrates the importance of using efficient, modular, and user-centric programming methods in modern app development.

import android.app.Activity
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.util.Log
import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.plugin.common.MethodChannel
class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.example.folder"
    private val REQUEST_CODE_OPEN_DOCUMENT_TREE = 1001
    private var resultCallback: MethodChannel.Result? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        MethodChannel(flutterEngine?.dartExecutor?.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
            resultCallback = result
            when (call.method) {
                "pickFolder" -> openFolderPicker()
                else -> result.notImplemented()
            }
        }
    }
    private fun openFolderPicker() {
        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION or Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION)
        }
        startActivityForResult(intent, REQUEST_CODE_OPEN_DOCUMENT_TREE)
    }
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_CODE_OPEN_DOCUMENT_TREE && resultCode == Activity.RESULT_OK) {
            val uri = data?.data
            if (uri != null) {
                contentResolver.takePersistableUriPermission(uri,
                    Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
                resultCallback?.success(uri.toString())
            } else {
                resultCallback?.error("FOLDER_SELECTION_CANCELLED", "No folder was selected.", null)
            }
        }
    }
}

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
class FolderPickerScreen extends StatefulWidget {
  @override
  _FolderPickerScreenState createState() => _FolderPickerScreenState();
}
class _FolderPickerScreenState extends State<FolderPickerScreen> {
  static const platform = MethodChannel('com.example.folder');
  String folderPath = "No folder selected.";
  Future<void> pickFolder() async {
    try {
      final String? result = await platform.invokeMethod('pickFolder');
      setState(() {
        folderPath = result ?? "No folder selected.";
      });
    } on PlatformException catch (e) {
      setState(() {
        folderPath = "Error: ${e.message}";
      });
    }
  }
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text("Folder Picker")),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: [
              Text(folderPath),
              ElevatedButton(
                onPressed: pickFolder,
                child: Text("Pick Folder"),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

Optimizing Folder Picker Workflow with Persistent Permissions

One often-overlooked aspect of using the Storage Access Framework (SAF) in Flutter is ensuring the app maintains a balance between user convenience and proper permission management. When users interact with the folder picker repeatedly, it's vital to implement a system that eliminates redundant permission prompts while retaining the ability to select different folders as needed. This ensures a seamless experience for tasks like file storage or directory management. By persisting permissions using takePersistableUriPermission, developers can greatly enhance their app's usability, particularly in applications like document managers or media libraries. 📂

Another critical consideration is error handling and state management. For instance, when the app fetches a previously saved URI, it’s essential to verify that the permissions for the folder are still valid. This can be achieved by examining persistedUriPermissions. If permissions are invalid or missing, the app must gracefully reset the state and prompt the user to select a new folder. This modular approach allows developers to easily maintain the code and provide a better user experience. Additionally, adding proper feedback to the user through Flutter UI ensures clarity, such as displaying folder paths or error messages when selection fails.

Finally, developers can optimize their apps further by integrating unit tests. These tests can validate whether the URI persistence works correctly across scenarios, including app restarts and folder changes. A practical example would be a photo editing app, where users save output files in a directory of their choice. With the SAF framework, such apps can avoid repetitive permission requests, improving overall performance and user satisfaction. 🚀