### Build and Install from Source

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Configures, builds, and installs jmtpfs from its source code.

```bash
./configure
make
sudo make install
```

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

### Demonstrate MtpNode Operations

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Shows how to get node attributes, list directory contents, create subdirectories and files, and retrieve filesystem statistics using MtpNode.

```cpp
#include "MtpNode.h"
#include "MtpFuseContext.h"
#include <sys/stat.h>

void demonstrateMtpNode(MtpFuseContext& context) {
    FilesystemPath path("/Internal Storage/Documents");

    // Get node for path
    std::unique_ptr<MtpNode> node = context.getNode(path);

    // Get file/directory attributes
    struct stat info;
    node->getattr(info);
    std::cout << "Size: " << info.st_size << std::endl;
    std::cout << "Is directory: " << (S_ISDIR(info.st_mode) ? "yes" : "no") << std::endl;

    // Read directory contents
    std::vector<std::string> contents = node->readdir();
    for (const auto& entry : contents) {
        std::cout << "  " << entry << std::endl;
    }

    // Create subdirectory
    node->mkdir("NewSubfolder");

    // Create empty file
    node->CreateFile("newfile.txt");

    // Get filesystem statistics
    struct statvfs fsStats;
    node->statfs(&fsStats);
    std::cout << "Block size: " << fsStats.f_bsize << std::endl;
    std::cout << "Free blocks: " << fsStats.f_bfree << std::endl;
}
```

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

### Install Dependencies on Fedora/RHEL

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Installs necessary development libraries for FUSE, libmtp, and libmagic, along with a C++ compiler on Fedora or RHEL-based systems.

```bash
sudo yum install fuse-devel libmtp-devel file-devel gcc-c++
```

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

### Demonstrate MtpFolder Operations

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Shows how to list directory contents, navigate to child nodes, create subdirectories and files, get folder attributes, and delete folders using MtpFolder. The folder must be empty to be deleted.

```cpp
#include "MtpFolder.h"

void demonstrateMtpFolder(MtpDevice& device, MtpMetadataCache& cache,
                          uint32_t storageId, uint32_t folderId) {
    MtpFolder folder(device, cache, storageId, folderId);

    // List folder contents
    std::vector<std::string> entries = folder.readDirectory();
    for (const auto& entry : entries) {
        std::cout << entry << std::endl;
    }

    // Navigate to child node
    FilesystemPath childPath("Subfolder/document.txt");
    std::unique_ptr<MtpNode> childNode = folder.getNode(childPath);

    // Create new subdirectory
    folder.mkdir("NewSubfolder");

    // Create new empty file
    folder.CreateFile("newfile.txt");

    // Get folder attributes
    struct stat info;
    folder.getattr(info);
    std::cout << "Folder ID: " << folder.FolderId() << std::endl;
    std::cout << "Storage ID: " << folder.StorageId() << std::endl;

    // Delete folder (must be empty)
    folder.Remove();
}
```

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

### Install Dependencies on Debian/Ubuntu

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Installs required development libraries for FUSE, libmtp, and libmagic, plus the g++ compiler on Debian or Ubuntu systems.

```bash
sudo apt-get install libfuse-dev libmtp-dev libmagic-dev g++
```

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

### Install Dependencies on Mac OS X (MacPorts)

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Installs libmtp and osxfuse using MacPorts for macOS compatibility.

```bash
sudo port install libmtp osxfuse
```

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

### Interact with an MTP Device (C++)

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Use the MtpDevice class for low-level operations like getting storage info, listing files, creating folders, downloading, and deleting objects.

```cpp
#include "MtpDevice.h"
#include <iostream>
#include <fcntl.h>
#include <unistd.h>

void demonstrateMtpDevice(MtpDevice& device) {
    // Get device model name
    std::string modelName = device.Get_Modelname();
    std::cout << "Connected to: " << modelName << std::endl;

    // List storage devices (Internal Storage, SD Card, etc.)
    std::vector<MtpStorageInfo> storages = device.GetStorageDevices();
    for (const auto& storage : storages) {
        std::cout << "Storage: " << storage.description << std::endl;
        std::cout << "  ID: " << storage.id << std::endl;
        std::cout << "  Free: " << (storage.freeSpaceInBytes / 1024 / 1024) << " MB" << std::endl;
        std::cout << "  Capacity: " << (storage.maxCapacity / 1024 / 1024) << " MB" << std::endl;
    }

    // Get folder contents (root folder has id 0xFFFFFFFF)
    uint32_t storageId = storages[0].id;
    std::vector<MtpFileInfo> files = device.GetFolderContents(storageId, 0xFFFFFFFF);

    for (const auto& file : files) {
        std::cout << "  " << file.name;
        if (file.filetype == LIBMTP_FILETYPE_FOLDER) {
            std::cout << "/";
        } else {
            std::cout << " (" << file.filesize << " bytes)";
        }
        std::cout << std::endl;
    }

    // Create a new folder
    device.CreateFolder("MyNewFolder", 0xFFFFFFFF, storageId);

    // Download a file from device
    MtpFileInfo fileInfo = device.GetFileInfo(someFileId);
    int fd = open("/tmp/downloaded_file", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    device.GetFile(fileInfo.id, fd);
    close(fd);

    // Delete an object (file or empty folder)
    device.DeleteObject(someFileId);
}
```

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

### Display MTP Storage Information

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Retrieves and displays information about MTP storage devices, including description, ID, capacity, used space, and free space. It also shows how to get specific storage info by ID.

```cpp
#include "MtpDevice.h"
#include <iostream>
#include <iomanip>

void displayStorageInfo(MtpDevice& device) {
    std::vector<MtpStorageInfo> storages = device.GetStorageDevices();

    for (const auto& storage : storages) {
        std::cout << "Storage: " << storage.description << std::endl;
        std::cout << "  Storage ID: " << storage.id << std::endl;

        double freeGB = storage.freeSpaceInBytes / (1024.0 * 1024.0 * 1024.0);
        double totalGB = storage.maxCapacity / (1024.0 * 1024.0 * 1024.0);
        double usedGB = totalGB - freeGB;
        double usedPercent = (usedGB / totalGB) * 100.0;

        std::cout << std::fixed << std::setprecision(2);
        std::cout << "  Capacity: " << totalGB << " GB" << std::endl;
        std::cout << "  Used: " << usedGB << " GB (" << usedPercent << "%)" << std::endl;
        std::cout << "  Free: " << freeGB << " GB" << std::endl;
    }

    // Get specific storage info by ID
    MtpStorageInfo internalStorage = device.GetStorageInfo(storages[0].id);
}
```

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

### Create and Remove Directories

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Shows how to create a new directory, nested directories, and then remove an empty directory and a directory tree using `mkdir`, `mkdir -p`, `rmdir`, and `rm -r`.

```bash
mkdir ~/mtp/Internal\ Storage/MyPhotos
mkdir -p ~/mtp/Internal\ Storage/Documents/Work/Reports
ls ~/mtp/Internal\ Storage/Documents/
rmdir ~/mtp/Internal\ Storage/MyPhotos
rm -r ~/mtp/Internal\ Storage/Documents/
```

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

### Create and Read Text File

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Demonstrates creating a text file named 'test.txt' with content and then reading its content back using standard shell redirection and `cat` command within the mounted MTP filesystem.

```bash
cd ~/mtp/Internal\ Storage/
cat > test.txt << EOF
Hello Android!
This is a test file created from Linux.
EOF

cat test.txt
```

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

### Demonstrate MtpFile Operations

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Illustrates file operations such as opening, reading, writing, truncating, renaming, and removing files using MtpFile. Note that file operations download to a temporary location and upload changes upon closing.

```cpp
#include "MtpFile.h"
#include <cstring>

void demonstrateMtpFile(MtpDevice& device, MtpMetadataCache& cache, uint32_t fileId) {
    MtpFile file(device, cache, fileId);

    // Open file (downloads entire file to temp location)
    file.Open();

    // Read data from file
    char buffer[1024];
    int bytesRead = file.Read(buffer, sizeof(buffer), 0);  // Read from offset 0
    std::cout << "Read " << bytesRead << " bytes" << std::endl;

    // Write data to file
    const char* newData = "Updated content";
    int bytesWritten = file.Write(newData, strlen(newData), 0);

    // Truncate file to specific length
    file.Truncate(100);

    // Close file (uploads changes back to device if modified)
    file.Close();

    // Rename file
    // MtpFolder newParent(...);
    // file.Rename(newParent, "renamed_file.txt");

    // Delete file
    file.Remove();
}
```

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

### Display jmtpfs Help and Version

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

View available command-line options and version information for jmtpfs.

```bash
# Display help
jmtpfs -h
# Output:
# usage: jmtpfs mountpoint [options]
#
# general options:
#     -o opt,[opt...]  mount options
#     -h   --help      print help
#     -V   --version   print version
#
# jmtpfs options:
#     -l    --listDevices         list available mtp devices and then exit
#     -device=<busnum>,<devnum>   Device to mount. If not specified the first device found is used

# Display version
jmtpfs -V
# Output:
# jmtpfs version: 0.5
# FUSE library version: 2.9.7
```

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

### Mount First Available MTP Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Creates a mount point and mounts the first detected MTP device to the specified directory. This command is used for basic access to MTP storage.

```bash
mkdir ~/mtp
jmtpfs ~/mtp
```

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

### Verify File Creation and Removal

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Verifies the creation of 'test.txt' by listing its details and then removes the file, followed by a verification of its removal.

```bash
ls -la test.txt
rm test.txt
ls test.txt
```

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

### Copy Files to MTP Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Demonstrates copying a single file, multiple files, and a directory recursively to the MTP device using the `cp` command.

```bash
cp ~/Photos/vacation.jpg ~/mtp/Internal\ Storage/Pictures/
cp ~/Music/*.mp3 ~/mtp/Internal\ Storage/Music/
cp -r ~/Documents/Project ~/mtp/Internal\ Storage/Documents/
```

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

### Command-Line Options

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Explore the available command-line options for jmtpfs, including help, version, and FUSE mount options.

```APIDOC
## Command-Line Options

### Display Help and Version

View available options and version information.

```bash
# Display help
jmtpfs -h
# Output:
# usage: jmtpfs mountpoint [options]
# 
# general options:
#     -o opt,[opt...]  mount options
#     -h   --help      print help
#     -V   --version   print version
# 
# jmtpfs options:
#     -l    --listDevices         list available mtp devices and then exit
#     -device=<busnum>,<devnum>   Device to mount. If not specified the first device found is used

# Display version
jmtpfs -V
# Output:
# jmtpfs version: 0.5
# FUSE library version: 2.9.7
```

### FUSE Mount Options

Pass standard FUSE options for additional control.

```bash
# Mount in foreground (useful for debugging)
jmtpfs -f ~/mtp

# Mount with debug output
jmtpfs -d ~/mtp

# Mount with specific permissions
jmtpfs -o uid=1000,gid=1000 ~/mtp

# Allow other users to access mount
jmtpfs -o allow_other ~/mtp
```
```

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

### Find and List MP4 Files with find

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Locate all MP4 files within a directory and display their details using find and ls.

```bash
find ~/mtp/Internal\ Storage/DCIM -name "*.mp4" -exec ls -lh {} \;
```

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

### C++ API: MtpDevice

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

The `MtpDevice` class provides low-level access to MTP device operations, including file transfers and storage management.

```APIDOC
### MtpDevice

Provides low-level access to MTP device operations including file transfers and storage management.

```cpp
#include "MtpDevice.h"
#include <iostream>
#include <fcntl.h>
#include <unistd.h>

void demonstrateMtpDevice(MtpDevice& device) {
    // Get device model name
    std::string modelName = device.Get_Modelname();
    std::cout << "Connected to: " << modelName << std::endl;

    // List storage devices (Internal Storage, SD Card, etc.)
    std::vector<MtpStorageInfo> storages = device.GetStorageDevices();
    for (const auto& storage : storages) {
        std::cout << "Storage: " << storage.description << std::endl;
        std::cout << "  ID: " << storage.id << std::endl;
        std::cout << "  Free: " << (storage.freeSpaceInBytes / 1024 / 1024) << " MB" << std::endl;
        std::cout << "  Capacity: " << (storage.maxCapacity / 1024 / 1024) << " MB" << std::endl;
    }

    // Get folder contents (root folder has id 0xFFFFFFFF)
    uint32_t storageId = storages[0].id;
    std::vector<MtpFileInfo> files = device.GetFolderContents(storageId, 0xFFFFFFFF);

    for (const auto& file : files) {
        std::cout << "  " << file.name;
        if (file.filetype == LIBMTP_FILETYPE_FOLDER) {
            std::cout << "/";
        } else {
            std::cout << " (" << file.filesize << " bytes)";
        }
        std::cout << std::endl;
    }

    // Create a new folder
    device.CreateFolder("MyNewFolder", 0xFFFFFFFF, storageId);

    // Download a file from device
    MtpFileInfo fileInfo = device.GetFileInfo(someFileId);
    int fd = open("/tmp/downloaded_file", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    device.GetFile(fileInfo.id, fd);
    close(fd);

    // Delete an object (file or empty folder)
    device.DeleteObject(someFileId);
}
```
```

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

### C++ API: ConnectedMtpDevices

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

The `ConnectedMtpDevices` class manages the discovery and connection to MTP devices attached to the system.

```APIDOC
## C++ API Classes

### ConnectedMtpDevices

Manages discovery and connection to MTP devices attached to the system.

```cpp
#include "ConnectedMtpDevices.h"
#include <iostream>

int main() {
    LIBMTP_Init();

    ConnectedMtpDevices devices;

    // Get number of connected devices
    int numDevices = devices.NumDevices();
    std::cout << "Found " << numDevices << " MTP device(s)" << std::endl;

    // List all devices
    for (int i = 0; i < numDevices; i++) {
        ConnectedDeviceInfo info = devices.GetDeviceInfo(i);
        std::cout << "Device " << i << ": " << info.vendor << " " << info.product << std::endl;
        std::cout << "  Bus: " << info.bus_location << ", DevNum: " << (int)info.devnum << std::endl;
        std::cout << "  VID: 0x" << std::hex << info.vendor_id
                  << ", PID: 0x" << info.product_id << std::dec << std::endl;
    }

    // Get first device
    std::unique_ptr<MtpDevice> device = devices.GetDevice(0);

    // Or get specific device by bus location and device number
    // std::unique_ptr<MtpDevice> device = devices.GetDevice(2, 19);

    return 0;
}
```
```

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

### List Connected MTP Devices

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Discovers and lists all connected MTP devices without mounting them. Useful for identifying devices before selecting one to mount.

```bash
jmtpfs -l
```

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

### Discover and List Connected MTP Devices (C++)

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Utilize the ConnectedMtpDevices class to find and retrieve information about connected MTP devices.

```cpp
#include "ConnectedMtpDevices.h"
#include <iostream>

int main() {
    LIBMTP_Init();

    ConnectedMtpDevices devices;

    // Get number of connected devices
    int numDevices = devices.NumDevices();
    std::cout << "Found " << numDevices << " MTP device(s)" << std::endl;

    // List all devices
    for (int i = 0; i < numDevices; i++) {
        ConnectedDeviceInfo info = devices.GetDeviceInfo(i);
        std::cout << "Device " << i << ": " << info.vendor << " " << info.product << std::endl;
        std::cout << "  Bus: " << info.bus_location << ", DevNum: " << (int)info.devnum << std::endl;
        std::cout << "  VID: 0x" << std::hex << info.vendor_id
                  << ", PID: 0x" << info.product_id << std::dec << std::endl;
    }

    // Get first device
    std::unique_ptr<MtpDevice> device = devices.GetDevice(0);

    // Or get specific device by bus location and device number
    // std::unique_ptr<MtpDevice> device = devices.GetDevice(2, 19);

    return 0;
}
```

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

### Copy Files from MTP Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Copies files, specifically JPEG images, from the MTP device's camera directory to a local backup directory using the `cp` command.

```bash
cp ~/mtp/Internal\ Storage/DCIM/Camera/*.jpg ~/Backup/
```

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

### Mount MTP Device with FUSE Options

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Configure jmtpfs mounting behavior using standard FUSE options for debugging or access control.

```bash
# Mount in foreground (useful for debugging)
jmtpfs -f ~/mtp

# Mount with debug output
jmtpfs -d ~/mtp

# Mount with specific permissions
jmtpfs -o uid=1000,gid=1000 ~/mtp

# Allow other users to access mount
jmtpfs -o allow_other ~/mtp
```

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

### Sync Files using rsync

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Synchronizes files from a local directory to the MTP device using `rsync`. Note that this operation might be slower due to MTP's rename limitations.

```bash
rsync -av --progress ~/Photos/ ~/mtp/Internal\ Storage/DCIM/Camera/
```

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

### Unmount MTP Device with fusermount

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Properly unmount an MTP filesystem using fusermount before disconnecting the device. Includes verification steps.

```bash
# List mounted filesystems to verify mount point
mount | grep jmtpfs
# Output: jmtpfs on /home/user/mtp type fuse.jmtpfs (rw,nosuid,nodev,user=user)

# Unmount the filesystem
fusermount -u ~/mtp

# Verify unmount
ls ~/mtp
# Output: (empty directory)

# Alternative: force unmount if busy
fusermount -uz ~/mtp
```

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

### Find JPEG Files on MTP Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Uses the `find` command to locate all files with a '.jpg' extension within the mounted MTP filesystem.

```bash
find ~/mtp/Internal\ Storage/ -name "*.jpg"
```

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

### Find Large Files with find

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Use the find command to locate files larger than a specified size (e.g., 100MB) in a directory.

```bash
find ~/mtp/Internal\ Storage/ -size +100M
```

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

### Display MTP File Information

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

This C++ function retrieves and displays metadata for a file on an MTP device, including its name, ID, size, modification date, and type. It requires the MtpDevice object and a file ID as input.

```cpp
#include "MtpDevice.h"
#include <ctime>

void displayFileInfo(MtpDevice& device, uint32_t fileId) {
    MtpFileInfo info = device.GetFileInfo(fileId);

    std::cout << "File: " << info.name << std::endl;
    std::cout << "  ID: " << info.id << std::endl;
    std::cout << "  Parent ID: " << info.parentId << std::endl;
    std::cout << "  Storage ID: " << info.storageId << std::endl;
    std::cout << "  Size: " << info.filesize << " bytes" << std::endl;

    // Display modification time
    char timeStr[100];
    std::strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S",
                  std::localtime(&info.modificationdate));
    std::cout << "  Modified: " << timeStr << std::endl;

    // Check file type
    switch (info.filetype) {
        case LIBMTP_FILETYPE_FOLDER:
            std::cout << "  Type: Folder" << std::endl;
            break;
        case LIBMTP_FILETYPE_JPEG:
            std::cout << "  Type: JPEG Image" << std::endl;
            break;
        case LIBMTP_FILETYPE_MP3:
            std::cout << "  Type: MP3 Audio" << std::endl;
            break;
        case LIBMTP_FILETYPE_MP4:
            std::cout << "  Type: MP4 Video" << std::endl;
            break;
        default:
            std::cout << "  Type: Other (" << info.filetype << ")" << std::endl;
    }
}
```

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

### FUSE Filesystem Callbacks

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Standard POSIX filesystem callbacks registered with FUSE to enable file operations on MTP devices.

```APIDOC
## FUSE Filesystem Operations

### Description
These functions are registered with FUSE and called automatically when filesystem operations are performed on the mount point.

### Operations
- **jmtpfs_getattr** - Get file/directory attributes
- **jmtpfs_readdir** - List directory contents
- **jmtpfs_open** - Open file for reading/writing
- **jmtpfs_read** - Read data from open file
- **jmtpfs_write** - Write data to open file
- **jmtpfs_release** - Close file (triggers upload if modified)
- **jmtpfs_create** - Create new file
- **jmtpfs_mkdir** - Create directory
- **jmtpfs_unlink** - Remove file
- **jmtpfs_rmdir** - Remove directory
- **jmtpfs_rename** - Rename/move file or directory
- **jmtpfs_truncate** - Truncate file to specified length
- **jmtpfs_statfs** - Get filesystem statistics
- **jmtpfs_flush** - Flush file data (sync)
- **jmtpfs_chmod** - Change file permissions (no-op)
- **jmtpfs_utime** - Change file timestamps (no-op)
```

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

### Unmounting the Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Properly unmount the MTP device filesystem before disconnecting to prevent data corruption.

```APIDOC
## Unmounting the Device

### Unmount with fusermount

Always unmount properly before disconnecting the device.

```bash
# List mounted filesystems to verify mount point
mount | grep jmtpfs
# Output: jmtpfs on /home/user/mtp type fuse.jmtpfs (rw,nosuid,nodev,user=user)

# Unmount the filesystem
fusermount -u ~/mtp

# Verify unmount
ls ~/mtp
# Output: (empty directory)

# Alternative: force unmount if busy
fusermount -uz ~/mtp
```
```

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

### MtpFileInfo Structure

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Describes the structure used to retrieve and display metadata for files and folders on an MTP device.

```APIDOC
## MtpFileInfo

### Description
Structure containing metadata about files and folders on the MTP device.

### Fields
- **name** (string) - File or folder name
- **id** (uint32_t) - Unique file identifier
- **parentId** (uint32_t) - Parent directory identifier
- **storageId** (uint32_t) - Storage device identifier
- **filesize** (uint32_t) - Size of the file in bytes
- **modificationdate** (time_t) - Last modification timestamp
- **filetype** (int) - Type of file (e.g., LIBMTP_FILETYPE_FOLDER, LIBMTP_FILETYPE_JPEG)
```

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

### Mount Specific MTP Device

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Mounts a specific MTP device using its bus location and device number, identified via the `jmtpfs -l` command. This is useful when multiple MTP devices are connected.

```bash
jmtpfs -device=2,19 ~/mtp
```

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

### Find Files Modified Recently

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

Uses the `find` command to locate files on the MTP device that have been modified within the last 7 days.

```bash
find ~/mtp/Internal\ Storage/ -mtime -7
```

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

### jmtpfs FUSE Callback Declarations

Source: https://context7.com/jasonferrara/jmtpfs/llms.txt

These C/C++ function declarations represent the FUSE callback functions used by jmtpfs to implement filesystem operations. They are registered with FUSE and invoked automatically when users interact with the mounted MTP device.

```c
// Get file/directory attributes (ls, stat)
extern "C" int jmtpfs_getattr(const char* path, struct stat* info);
```

```c
// List directory contents (ls, readdir)
extern "C" int jmtpfs_readdir(const char* path, void* buf, fuse_fill_dir_t filler,
                              off_t offset, struct fuse_file_info *fi);
```

```c
// Open file for reading/writing
extern "C" int jmtpfs_open(const char *path, struct fuse_file_info *fi);
```

```c
// Read data from open file
extern "C" int jmtpfs_read(const char *path, char *buf, size_t size,
                           off_t offset, struct fuse_file_info *fi);
```

```c
// Write data to open file
extern "C" int jmtpfs_write(const char *path, const char *data, size_t size,
                            off_t offset, struct fuse_file_info *fi);
```

```c
// Close file (triggers upload if modified)
extern "C" int jmtpfs_release(const char *path, struct fuse_file_info *fi);
```

```c
// Create new file
extern "C" int jmtpfs_create(const char* path, mode_t mode, struct fuse_file_info *fi);
```

```c
// Create directory
extern "C" int jmtpfs_mkdir(const char* path, mode_t mode);
```

```c
// Remove file
extern "C" int jmtpfs_unlink(const char *path);
```

```c
// Remove directory
extern "C" int jmtpfs_rmdir(const char* path);
```

```c
// Rename/move file or directory
extern "C" int jmtpfs_rename(const char *oldpath, const char *newpath);
```

```c
// Truncate file to specified length
extern "C" int jmtpfs_truncate(const char *path, off_t length);
```

```c
// Get filesystem statistics (df)
extern "C" int jmtpfs_statfs(const char *path, struct statvfs *stat);
```

```c
// Flush file data (sync)
extern "C" int jmtpfs_flush(const char *path, struct fuse_file_info *fi);
```

```c
// Change file permissions (no-op for MTP)
extern "C" int jmtpfs_chmod(const char* path, mode_t mode);
```

```c
// Change file timestamps (no-op for MTP)
extern "C" int jmtpfs_utime(const char* path, struct utimbuf* times);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.