Simple File Browser

https://github.com/yasirkula/unitysimplefilebrowser
Admin
Simple File Browser is a Unity plugin that provides an in-game file browser dialog for saving and...
Tokens:5,386
Snippets:43
Trust Score:7.1
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Request Storage Permissions on Android

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Handle Android runtime permissions for external storage access before showing the file browser. This example checks the current permission status and requests it if not granted, providing callbacks for different permission states.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class PermissionExample : MonoBehaviour
{
    void Start()
    {
        // Check current permission status
        if (!FileBrowser.CheckPermission())
        {
            Debug.Log("Storage permission not granted");
            RequestStoragePermission();
        }
    }

    void RequestStoragePermission()
    {
        FileBrowser.RequestPermissionAsync((permission) =>
        {
            switch (permission)
            {
                case FileBrowser.Permission.Granted:
                    Debug.Log("Permission granted - can access files");
                    ShowFileBrowser();
                    break;

                case FileBrowser.Permission.ShouldAsk:
                    Debug.Log("Permission denied - can ask again");
                    // Optionally show explanation then request again
                    break;

                case FileBrowser.Permission.Denied:
                    Debug.Log("Permission permanently denied - must use Settings");
                    // Direct user to app settings
                    break;
            }
        });
    }

    void ShowFileBrowser()
    {
        FileBrowser.ShowLoadDialog(
            (paths) => Debug.Log("Selected: " + paths[0]),
            () => Debug.Log("Cancelled"),
            FileBrowser.PickMode.Files
        );
    }
}
```

--------------------------------

### Custom Displayed Entries Filter

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Registers a function to programmatically control which files and folders are displayed. This example shows only directories starting with 'Save' and all files.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class CustomFilterExample : MonoBehaviour
{
    void Start()
    {
        // Only show directories that start with "Save" and all files
        FileBrowser.DisplayedEntriesFilter += FilterEntries;
    }

    bool FilterEntries(FileSystemEntry entry)
    {
        if (!entry.IsDirectory)
            return true; // Show all files

        // Only show directories starting with "Save"
        return entry.Name.StartsWith("Save");
    }

    void OnDestroy()
    {
        // Remove filter when done
        FileBrowser.DisplayedEntriesFilter -= FilterEntries;
    }
}
```

--------------------------------

### Custom Search Handler

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Overrides the default search behavior to implement custom search logic, such as regex matching. This example uses regex and falls back to simple contains if the regex is invalid.

```csharp
using SimpleFileBrowser;
using UnityEngine;
using System.Text.RegularExpressions;

public class CustomSearchExample : MonoBehaviour
{
    void Start()
    {
        // Use regex-based search
        FileBrowser.CustomSearchHandler += RegexSearch;
    }

    bool RegexSearch(FileSystemEntry entry, string searchTerm)
    {
        try
        {
            return Regex.IsMatch(entry.Name, searchTerm, RegexOptions.IgnoreCase);
        }
        catch
        {
            // Fall back to simple contains if regex is invalid
            return entry.Name.IndexOf(searchTerm, System.StringComparison.OrdinalIgnoreCase) >= 0;
        }
    }

    void OnDestroy()
    {
        FileBrowser.CustomSearchHandler -= RegexSearch;
    }
}
```

--------------------------------

### Show Load Dialog (Callback Approach)

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Displays a load dialog using callbacks. Use this when you need to handle the result asynchronously. Configure filters and the default filter before showing the dialog.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class LoadExample : MonoBehaviour
{
    void Start()
    {
        // Set up file filters (optional)
        FileBrowser.SetFilters(true,
            new FileBrowser.Filter("Images", ".jpg", ".png", ".gif"),
            new FileBrowser.Filter("Text Files", ".txt", ".pdf")
        );

        // Set default filter
        FileBrowser.SetDefaultFilter(".jpg");

        // Show the load dialog
        FileBrowser.ShowLoadDialog(
            onSuccess: (paths) => {
                Debug.Log("Selected file: " + paths[0]);
                // Process the selected file
                byte[] fileData = FileBrowserHelpers.ReadBytesFromFile(paths[0]);
            },
            onCancel: () => {
                Debug.Log("User cancelled");
            },
            pickMode: FileBrowser.PickMode.Files,
            allowMultiSelection: false,
            initialPath: null,
            initialFilename: null,
            title: "Select File",
            loadButtonText: "Load"
        );
    }
}
```

--------------------------------

### Show Load Dialog (Coroutine Approach)

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Shows a load dialog using a coroutine, pausing execution until the user interacts. This approach is suitable for synchronous-like handling of file selection. It supports multi-selection and file operations like copying.

```csharp
using SimpleFileBrowser;
using UnityEngine;
using System.Collections;
using System.IO;

public class CoroutineLoadExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(ShowLoadDialogCoroutine());
    }

    IEnumerator ShowLoadDialogCoroutine()
    {
        // Configure filters before showing dialog
        FileBrowser.SetFilters(true,
            new FileBrowser.Filter("Images", ".jpg", ".png"),
            new FileBrowser.Filter("Text Files", ".txt", ".pdf")
        );

        // Wait for user to select files
        yield return FileBrowser.WaitForLoadDialog(
            pickMode: FileBrowser.PickMode.Files,
            allowMultiSelection: true,
            initialPath: null,
            initialFilename: null,
            title: "Select Files",
            loadButtonText: "Load"
        );

        // Check results
        if (FileBrowser.Success)
        {
            string[] selectedPaths = FileBrowser.Result;
            foreach (string path in selectedPaths)
            {
                Debug.Log("Selected: " + path);
                string filename = FileBrowserHelpers.GetFilename(path);
                byte[] data = FileBrowserHelpers.ReadBytesFromFile(path);

                // Copy file to persistent data path
                string destPath = Path.Combine(Application.persistentDataPath, filename);
                FileBrowserHelpers.CopyFile(path, destPath);
            }
        }
    }
}
```

--------------------------------

### Add Quick Links

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Adds custom quick link shortcuts to the file browser sidebar for rapid navigation. Supports adding links with custom icons and platform-specific paths.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class QuickLinksExample : MonoBehaviour
{
    public Sprite customIcon;

    void Start()
    {
        // Add quick links to commonly used folders
        FileBrowser.AddQuickLink("Screenshots", Application.persistentDataPath + "/Screenshots", null);
        FileBrowser.AddQuickLink("Game Data", Application.persistentDataPath, null);

        // Add quick link with custom icon
        FileBrowser.AddQuickLink("Custom Folder", "C:\\MyFolder", customIcon);

        // Add platform-specific quick links
        #if UNITY_STANDALONE_WIN
        FileBrowser.AddQuickLink("Downloads",
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile) + "\\Downloads",
            null);
        #elif UNITY_STANDALONE_OSX
        FileBrowser.AddQuickLink("Downloads",
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.UserProfile) + "/Downloads",
            null);
        #endif
    }

    void ClearAllQuickLinks()
    {
        // Remove all quick links
        FileBrowser.ClearQuickLinks();
    }
}
```

--------------------------------

### Complete Unity File Browser Integration

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

This script demonstrates a full integration of the Simple File Browser for loading and saving images in a Unity application. It includes setting up filters, quick links, handling file loading with image preview, and saving images. Use FileBrowserHelpers for cross-platform compatibility, especially on Android 10+.

```csharp
using SimpleFileBrowser;
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.IO;

public class CompleteIntegrationExample : MonoBehaviour
{
    public RawImage previewImage;
    public Text statusText;

    void Start()
    {
        // Configure file browser once at startup
        FileBrowser.SetFilters(true,
            new FileBrowser.Filter("Images", ".jpg", ".png"),
            new FileBrowser.Filter("Text Files", ".txt", ".pdf")
        );
        FileBrowser.SetDefaultFilter(".jpg");
        FileBrowser.SetExcludedExtensions(".lnk", ".tmp", ".zip", ".rar", ".exe");

        // Add quick links
        FileBrowser.AddQuickLink("My Documents",
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments), null);
        FileBrowser.AddQuickLink("Game Data", Application.persistentDataPath, null);
    }

    public void OnLoadButtonClicked()
    {
        StartCoroutine(LoadImageCoroutine());
    }

    IEnumerator LoadImageCoroutine()
    {
        yield return FileBrowser.WaitForLoadDialog(
            FileBrowser.PickMode.Files,
            false,
            null,
            null,
            "Select Image",
            "Load"
        );

        if (FileBrowser.Success)
        {
            string path = FileBrowser.Result[0];
            statusText.text = "Loading: " + FileBrowserHelpers.GetFilename(path);

            // Read image bytes using FileBrowserHelpers (works on Android 10+)
            byte[] imageData = FileBrowserHelpers.ReadBytesFromFile(path);

            // Create texture from bytes
            Texture2D texture = new Texture2D(2, 2);
            if (texture.LoadImage(imageData))
            {
                previewImage.texture = texture;
                statusText.text = "Loaded: " + FileBrowserHelpers.GetFilename(path) +
                                  " (" + FileBrowserHelpers.GetFilesize(path) + " bytes)";

                // Copy to persistent data path for later use
                string localPath = Path.Combine(Application.persistentDataPath,
                    FileBrowserHelpers.GetFilename(path));
                FileBrowserHelpers.CopyFile(path, localPath);
            }
            else
            {
                statusText.text = "Failed to load image";
            }
        }
    }

    public void OnSaveButtonClicked()
    {
        if (previewImage.texture == null) return;
        StartCoroutine(SaveImageCoroutine());
    }

    IEnumerator SaveImageCoroutine()
    {
        FileBrowser.SetFilters(false, new FileBrowser.Filter("PNG Image", ".png"));

        yield return FileBrowser.WaitForSaveDialog(
            FileBrowser.PickMode.Files,
            false,
            null,
            "exported_image.png",
            "Save Image",
            "Save"
        );

        if (FileBrowser.Success)
        {
            string savePath = FileBrowser.Result[0];
            Texture2D tex = (Texture2D)previewImage.texture;
            byte[] pngData = tex.EncodeToPNG();

            FileBrowserHelpers.WriteBytesToFile(savePath, pngData);
            statusText.text = "Saved to: " + savePath;
        }
    }
}
```

--------------------------------

### Show Save Dialog

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Displays a save dialog to allow users to specify a filename and location. The returned path can point to non-existing files. Ensure to set filters before showing the dialog.

```csharp
using SimpleFileBrowser;
using UnityEngine;
using System.Collections;

public class SaveExample : MonoBehaviour
{
    public byte[] dataToSave;

    void Start()
    {
        StartCoroutine(SaveFileCoroutine());
    }

    IEnumerator SaveFileCoroutine()
    {
        // Set filters for save dialog
        FileBrowser.SetFilters(false,
            new FileBrowser.Filter("PNG Image", ".png"),
            new FileBrowser.Filter("JPEG Image", ".jpg")
        );

        // Show save dialog
        yield return FileBrowser.WaitForSaveDialog(
            pickMode: FileBrowser.PickMode.Files,
            allowMultiSelection: false,
            initialPath: null,
            initialFilename: "screenshot.png",
            title: "Save Screenshot",
            saveButtonText: "Save"
        );

        if (FileBrowser.Success)
        {
            string savePath = FileBrowser.Result[0];
            Debug.Log("Saving to: " + savePath);

            // Write data to the selected path
            FileBrowserHelpers.WriteBytesToFile(savePath, dataToSave);
        }
    }
}
```

--------------------------------

### Folder Selection Dialog

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Allows users to select folders instead of files using PickMode.Folders. This is useful for choosing export directories. It also demonstrates creating files and subfolders within the selected directory.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class FolderSelectExample : MonoBehaviour
{
    void SelectOutputFolder()
    {
        FileBrowser.ShowLoadDialog(
            onSuccess: (paths) => {
                string selectedFolder = paths[0];
                Debug.Log("Selected folder: " + selectedFolder);

                // Create a new file in the selected folder
                string newFilePath = FileBrowserHelpers.CreateFileInDirectory(
                    selectedFolder,
                    "output.txt"
                );
                FileBrowserHelpers.WriteTextToFile(newFilePath, "Hello World!");

                // Create a subfolder
                string newFolderPath = FileBrowserHelpers.CreateFolderInDirectory(
                    selectedFolder,
                    "NewSubfolder"
                );
            },
            onCancel: () => Debug.Log("Cancelled"),
            pickMode: FileBrowser.PickMode.Folders,
            allowMultiSelection: false,
            initialPath: Application.persistentDataPath,
            initialFilename: null,
            title: "Select Output Folder",
            loadButtonText: "Select"
        );
    }
}
```

--------------------------------

### Configure Image File Filters

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Sets file filters to display images, including an 'All Files' option. The default filter is set to '.jpg'.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class FilterExample : MonoBehaviour
{
    void ConfigureImageFilters()
    {
        // Show "All Files" filter + specific filters
        FileBrowser.SetFilters(true,
            new FileBrowser.Filter("Images", ".jpg", ".jpeg", ".png", ".gif", ".bmp"),
            new FileBrowser.Filter("PNG Files", ".png"),
            new FileBrowser.Filter("JPEG Files", ".jpg", ".jpeg")
        );

        // Set default filter to Images
        FileBrowser.SetDefaultFilter(".jpg");
    }

    void ConfigureDocumentFilters()
    {
        // Hide "All Files" filter - only show specific types
        FileBrowser.SetFilters(false,
            new FileBrowser.Filter("Documents", ".txt", ".pdf", ".doc", ".docx"),
            new FileBrowser.Filter("Text Files", ".txt"),
            new FileBrowser.Filter("PDF Files", ".pdf")
        );
    }

    void ConfigureSimpleFilters()
    {
        // Simple string-based filters
        FileBrowser.SetFilters(true, ".mp3", ".wav", ".ogg");
    }
}
```

--------------------------------

### Perform File Operations

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Use this snippet to check file/directory existence, retrieve file metadata, read/write file contents, and append data. Ensure the file path is valid before operations.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class FileOperationsExample : MonoBehaviour
{
    void PerformFileOperations(string filePath)
    {
        // Check if file/directory exists
        bool fileExists = FileBrowserHelpers.FileExists(filePath);
        bool dirExists = FileBrowserHelpers.DirectoryExists(filePath);
        bool isDir = FileBrowserHelpers.IsDirectory(filePath);

        // Get file information
        string filename = FileBrowserHelpers.GetFilename(filePath);
        long fileSize = FileBrowserHelpers.GetFilesize(filePath);
        System.DateTime lastModified = FileBrowserHelpers.GetLastModifiedDate(filePath);
        string parentDir = FileBrowserHelpers.GetDirectoryName(filePath);

        Debug.Log($"File: {filename}, Size: {fileSize}, Modified: {lastModified}");

        // Read file contents
        byte[] bytes = FileBrowserHelpers.ReadBytesFromFile(filePath);
        string text = FileBrowserHelpers.ReadTextFromFile(filePath);

        // Write file contents
        FileBrowserHelpers.WriteBytesToFile(filePath, bytes);
        FileBrowserHelpers.WriteTextToFile(filePath, "New content");

        // Append to file
        FileBrowserHelpers.AppendBytesToFile(filePath, new byte[] { 0x00 });
        FileBrowserHelpers.AppendTextToFile(filePath, "\nAppended text");
    }

    void CopyMoveOperations(string sourcePath, string destPath)
    {
        // Copy operations
        FileBrowserHelpers.CopyFile(sourcePath, destPath);
        FileBrowserHelpers.CopyDirectory(sourcePath, destPath);

        // Move operations
        FileBrowserHelpers.MoveFile(sourcePath, destPath);
        FileBrowserHelpers.MoveDirectory(sourcePath, destPath);

        // Rename operations (returns new path)
        string newFilePath = FileBrowserHelpers.RenameFile(sourcePath, "newname.txt");
        string newDirPath = FileBrowserHelpers.RenameDirectory(sourcePath, "NewFolderName");
    }

    void CreateAndDeleteOperations(string directoryPath)
    {
        // Create new file in directory (returns created file path)
        string newFile = FileBrowserHelpers.CreateFileInDirectory(directoryPath, "newfile.txt");

        // Create new folder in directory (returns created folder path)
        string newFolder = FileBrowserHelpers.CreateFolderInDirectory(directoryPath, "NewFolder");

        // Delete file or directory
        FileBrowserHelpers.DeleteFile(newFile);
        FileBrowserHelpers.DeleteDirectory(newFolder);
    }

    void ListDirectoryContents(string directoryPath)
    {
        // Get all entries in a directory
        FileSystemEntry[] entries = FileBrowserHelpers.GetEntriesInDirectory(directoryPath, true);

        if (entries != null)
        {
            foreach (FileSystemEntry entry in entries)
            {
                Debug.Log($"Name: {entry.Name}, Path: {entry.Path}, " +
                         $
```

```csharp
bool isChild = FileBrowserHelpers.IsPathDescendantOfAnother(
            "/path/to/child/file.txt",
            "/path/to"
        );
    }
}
```

--------------------------------

### Configure File Browser Properties

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Adjusts various file browser settings such as display of hidden files, single-click mode, permission handling, and UI text labels.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class ConfigurationExample : MonoBehaviour
{
    void ConfigureFileBrowser()
    {
        // Enable/disable hidden files display
        FileBrowser.ShowHiddenFiles = true;

        // Show/hide the "Show hidden files" toggle in UI
        FileBrowser.DisplayHiddenFilesToggle = true;

        // Enable single-click mode (open files/folders with single click)
        FileBrowser.SingleClickMode = true;

        // Disable permission requests on Android (handle manually)
        FileBrowser.AskPermissions = false;

        // Configure file overwrite confirmation dialog
        FileBrowser.ShowFileOverwriteDialog = true;

        // Enable write access check before saving
        FileBrowser.CheckWriteAccessToDestinationDirectory = true;

        // Allow/disallow file operations
        FileBrowser.CanDeleteFiles = true;
        FileBrowser.CanRenameFiles = true;

        // Set drive refresh interval (seconds, -1 to disable)
        FileBrowser.DrivesRefreshInterval = 5f;

        // Customize filter text labels
        FileBrowser.AllFilesFilterText = "All Files (*.*)";
        FileBrowser.FoldersFilterText = "Folders";
        FileBrowser.PickFolderQuickLinkText = "Browse...";

        // Change UI skin at runtime
        // FileBrowser.Skin = myCustomSkin;
    }
}
```

--------------------------------

### Exclude File Extensions

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Specifies file extensions that should not be displayed in the file browser. This can be used to exclude system or archive files.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class ExcludeExtensionsExample : MonoBehaviour
{
    void Start()
    {
        // Exclude system and temporary files (defaults are .lnk and .tmp)
        FileBrowser.SetExcludedExtensions(".lnk", ".tmp", ".sys", ".dll", ".exe");

        // Exclude archive files
        FileBrowser.SetExcludedExtensions(".lnk", ".tmp", ".zip", ".rar", ".7z");
    }
}
```

--------------------------------

### Hide File Browser Dialog Programmatically

Source: https://context7.com/yasirkula/unitysimplefilebrowser/llms.txt

Force close an open file browser dialog from code. Optionally invoke the cancel callback. Useful for closing the dialog on events like pausing the game or pressing the Escape key.

```csharp
using SimpleFileBrowser;
using UnityEngine;

public class HideDialogExample : MonoBehaviour
{
    void Update()
    {
        // Close dialog when Escape is pressed
        if (FileBrowser.IsOpen && Input.GetKeyDown(KeyCode.Escape))
        {
            // Hide without invoking cancel callback
            FileBrowser.HideDialog(invokeCancelCallback: false);
        }
    }

    public void OnGamePaused()
    {
        if (FileBrowser.IsOpen)
        {
            // Hide and invoke cancel callback
            FileBrowser.HideDialog(invokeCancelCallback: true);
        }
    }

    void PreloadFileBrowser()
    {
        // Initialize file browser ahead of time to reduce lag on first open
        FileBrowser.HideDialog(false);
    }
}
```
Tokens:
Raw