In order to handle per folder permissions, I think you should use Android’s persistedUriPermissions API. This allows you to retrieve previously used folders, while also giving you the option to add new ones as the users use your app and grant relevant permissions.

Here is an example of the changes you can make to your flutter activity:

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.documentfile.provider.DocumentFile
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)

        val messenger = flutterEngine?.dartExecutor?.binaryMessenger
        if (messenger != null) {
            MethodChannel(messenger, CHANNEL).setMethodCallHandler { call, result ->
                resultCallback = result
                when (call.method) {
                    "pickFolder" -> openFolderPicker()
                    "getPersistedFolders" -> getPersistedFolders(result)
                    "usePersistedFolder" -> usePersistedFolder(call.arguments as String, result)
                    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)
    }

    private fun getPersistedFolders(result: MethodChannel.Result) {
        val persistedUris = contentResolver.persistedUriPermissions.map { permission ->
            mapOf(
                "uri" to permission.uri.toString(),
                "name" to (DocumentFile.fromTreeUri(this, permission.uri)?.name ?: "Unknown Folder")
            )
        }
        result.success(persistedUris)
    }

    private fun usePersistedFolder(uriString: String, result: MethodChannel.Result) {
        val uri = Uri.parse(uriString)
        val hasPermission = contentResolver.persistedUriPermissions.any {
            it.uri == uri && it.isReadPermission && it.isWritePermission
        }
        
        if (hasPermission) {
            result.success(uriString)
        } else {
            result.error("PERMISSION_DENIED", "No permission for this folder", null)
        }
    }

    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)
            }
        }
    }
}

If you want users to be able to select previously used folders, you can display them for example in an Expanded widget like so:

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? selectedFolderUri;
  List<Map<String, dynamic>> persistedFolders = [];

  @override
  void initState() {
    super.initState();
    loadPersistedFolders();
  }

  Future<void> loadPersistedFolders() async {
    try {
      final List<dynamic> result = await platform.invokeMethod('getPersistedFolders');
      setState(() {
        persistedFolders = List<Map<String, dynamic>>.from(result);
      });
    } on PlatformException catch (e) {
      print("Error loading persisted folders: ${e.message}");
    }
  }

  Future<void> pickNewFolder() async {
    try {
      final String? result = await platform.invokeMethod('pickFolder');
      if (result != null) {
        setState(() {
          selectedFolderUri = result;
        });
        await loadPersistedFolders(); // Refresh the list
      }
    } on PlatformException catch (e) {
      print("Error picking folder: ${e.message}");
    }
  }

  Future<void> usePersistedFolder(String uri) async {
    try {
      final String? result = await platform.invokeMethod('usePersistedFolder', uri);
      if (result != null) {
        setState(() {
          selectedFolderUri = result;
        });
      }
    } on PlatformException catch (e) {
      print("Error using persisted folder: ${e.message}");
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("Folder Picker")),
      body: Column(
        children: [
          Padding(
            padding: const EdgeInsets.all(16.0),
            child: Text(
              "Selected Folder: ${selectedFolderUri ?? 'None'}",
              style: Theme.of(context).textTheme.bodyLarge,
            ),
          ),
          ElevatedButton(
            onPressed: pickNewFolder,
            child: Text("Pick New Folder"),
          ),
          if (persistedFolders.isNotEmpty) ...[
            Padding(
              padding: const EdgeInsets.all(16.0),
              child: Text(
                "Previously Selected Folders:",
                style: Theme.of(context).textTheme.titleMedium,
              ),
            ),
            Expanded(
              child: ListView.builder(
                itemCount: persistedFolders.length,
                itemBuilder: (context, index) {
                  final folder = persistedFolders[index];
                  return ListTile(
                    title: Text(folder['name'] as String),
                    subtitle: Text(folder['uri'] as String),
                    onTap: () => usePersistedFolder(folder['uri'] as String),
                  );
                },
              ),
            ),
          ],
        ],
      ),
    );
  }
}