@Override
public ParcelFileDescriptor openLargeFile(String path) {
    File file = new File(path);
    return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
    // Binder 只传了 fd（几十字节），5GB 的文件也没问题
}

try {
    ParcelFileDescriptor pfd = myService.openLargeFile("/data/large.bin");
    InputStream is = new ParcelFileDescriptor.AutoCloseInputStream(pfd);
    // 流式读取，文件内容不经过 Binder
} catch (RemoteException e) {
    // Binder 调用必须 try-catch
}

public @Nullable ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String mode)
        throws FileNotFoundException {
    throw new FileNotFoundException("No files supported by provider at " + uri);
}

@Override
public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
    File file = getFileForUri(uri);
    int fileMode = modeToMode(mode);
    return ParcelFileDescriptor.open(file, fileMode);  // 返回 fd
}

// 发送方
Uri fileUri = FileProvider.getUriForFile(context, authority, largeFile);
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_STREAM, fileUri);
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(intent);

// 接收方
Uri uri = intent.getParcelableExtra(Intent.EXTRA_STREAM);
InputStream is = getContentResolver().openInputStream(uri);  // 底层走 ContentProvider → fd

public class ParcelFileDescriptor implements Parcelable, Closeable {

public final class SharedMemory implements Parcelable, Closeable {
    private final FileDescriptor mFileDescriptor;
    private final int mSize;
}

public static SharedMemory create(String name, int size) throws ErrnoException {
    return new SharedMemory(nCreate(name, size));  // 底层调用 ashmem_create_region
}

public ByteBuffer mapReadWrite() throws ErrnoException {
    return map(OsConstants.PROT_READ | OsConstants.PROT_WRITE, 0, mSize);
}

public ByteBuffer mapReadOnly() throws ErrnoException {
    return map(OsConstants.PROT_READ, 0, mSize);
}

@Override
public SharedMemory getLargeData() throws RemoteException {
    try {
        SharedMemory shm = SharedMemory.create("data", 4 * 1024 * 1024);
        ByteBuffer buf = shm.mapReadWrite();
        buf.put(largeByteArray);  // 写入 4MB 数据
        SharedMemory.unmap(buf);
        return shm;  // Binder 只传 fd，对端 mmap 零拷贝读取
    } catch (ErrnoException e) {
        throw new RemoteException(e.getMessage());
    }
}

/**
 * A buffer containing multiple cursor rows.
 *
 * A CursorWindow is read-write when initially created and used locally.
 * When sent to a remote process (by writing it to a Parcel), the remote process
 * receives a read-only view of the cursor window.
 */
public class CursorWindow extends SQLiteClosable implements Parcelable {

/**
 * This shared memory region can be used as an alternative to Binder IPC for driving
 * communication between system processes and application processes at a lower latency
 * and higher throughput than Binder IPC can provide.
 *
 * Unlike Binder IPC, shared memory doesn't support synchronous transactions,
 * client identity, and access auditing.
 */
public class ApplicationSharedMemory implements AutoCloseable {

public static ApplicationSharedMemory create() {
    int fd = nativeCreate();               // 分配共享内存
    long ptr = nativeMap(fd, true);        // 可读写映射
    nativeInit(ptr);
    return new ApplicationSharedMemory(fileDescriptor, true, ptr);
}

public static ApplicationSharedMemory fromFileDescriptor(
        FileDescriptor fileDescriptor, boolean mutable) {
    long ptr = nativeMap(fileDescriptor.getInt$(), mutable);  // 只读映射
    return new ApplicationSharedMemory(fileDescriptor, mutable, ptr);
}

public <T> ParcelFileDescriptor openPipeHelper(final Uri uri,
        final String mimeType, final Bundle opts, final T args,
        final PipeDataWriter<T> func) throws FileNotFoundException {
    try {
        final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createPipe();  // 创建管道

        // 后台线程写入数据
        AsyncTask<Object, Object, Object> task = new AsyncTask<>() {
            @Override
            protected Object doInBackground(Object... params) {
                func.writeDataToPipe(fds[1], uri, mimeType, opts, args);  // 写入写端
                fds[1].close();  // 关闭写端 → 读端收到 EOF
                return null;
            }
        };
        task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Object[]) null);

        return fds[0];  // 返回读端给调用方（通过 Binder 传递 fd）
    } catch (IOException e) {
        throw new FileNotFoundException("failure making pipe");
    }
}

public static ParcelFileDescriptor[] createPipe() throws IOException {
    try {
        final FileDescriptor[] fds = Os.pipe2(ifAtLeastQ(O_CLOEXEC));
        return new ParcelFileDescriptor[] {
                new ParcelFileDescriptor(fds[0]),   // 读端
                new ParcelFileDescriptor(fds[1]) }; // 写端
    } catch (ErrnoException e) {
        throw e.rethrowAsIOException();
    }
}

@Override
public ParcelFileDescriptor streamAnimationData() throws RemoteException {
    try {
        ParcelFileDescriptor[] pipe = ParcelFileDescriptor.createPipe();
        new Thread(() -> {
            try (OutputStream os = new ParcelFileDescriptor.AutoCloseOutputStream(pipe[1])) {
                writeHugeDataTo(os);  // 后台线程流式写入，无大小限制
            } catch (IOException e) { }
        }).start();
        return pipe[0];  // 返回读端，Binder 只传 fd
    } catch (IOException e) {
        throw new RemoteException(e.getMessage());
    }
}

// 服务端
LocalServerSocket server = new LocalServerSocket("my_transfer");
LocalSocket client = server.accept();
OutputStream os = client.getOutputStream();
os.write(hugeFileBytes);  // 直接写，无 Binder 参与

// 客户端
LocalSocket socket = new LocalSocket();
socket.connect(new LocalSocketAddress("my_transfer"));
InputStream is = socket.getInputStream();
// 流式读取，无大小限制

// 进程 A：写入文件
File shared = new File(context.getFilesDir(), "shared_data.bin");
writeDataToFile(shared, largeData);

// 通过 Binder 只传路径字符串（几十字节）
myService.notifyFileReady(shared.getAbsolutePath());

// 进程 B：直接打开
File shared = new File(path);
readDataFromFile(shared);