Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am 963cd006: Allow creating AssetFileDescriptors for MemoryFiles.

Browse Source 
Merge commit '963cd006c45716b034f656bf7e7179e6476f7e4d'

* commit '963cd006c45716b034f656bf7e7179e6476f7e4d':
  Allow creating AssetFileDescriptors for MemoryFiles.
This commit is contained in:
Bjorn Bringert
2009-06-03 04:56:49 -07:00
committed by The Android Open Source Project
parent ae8c5b868f 963cd006c4
commit c0cbfda0fe
7 changed files with 575 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
core/java/android/content/res/AssetFileDescriptor.java
View File

@@ -16,6 +16,7 @@
package android.content.res;
import android.os.MemoryFile;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.Parcelable;
@@ -24,6 +25,8 @@ import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.channels.FileChannel;
/**
* File descriptor of an entry in the AssetManager. This provides your own
@@ -123,6 +126,13 @@ public class AssetFileDescriptor implements Parcelable {
mFd.close();
}
/**
* Checks whether this file descriptor is for a memory file.
*/
private boolean isMemoryFile() throws IOException {
return MemoryFile.isMemoryFile(mFd.getFileDescriptor());
}
/**
* Create and return a new auto-close input stream for this asset. This
* will either return a full asset {@link AutoCloseInputStream}, or
@@ -132,6 +142,12 @@ public class AssetFileDescriptor implements Parcelable {
* should only call this once for a particular asset.
*/
public FileInputStream createInputStream() throws IOException {
if (isMemoryFile()) {
if (mLength > Integer.MAX_VALUE) {
throw new IOException("File length too large for a memory file: " + mLength);
}
return new AutoCloseMemoryFileInputStream(mFd, (int)mLength);
}
if (mLength < 0) {
return new ParcelFileDescriptor.AutoCloseInputStream(mFd);
}
@@ -261,6 +277,66 @@ public class AssetFileDescriptor implements Parcelable {
}
}
/**
* An input stream that reads from a MemoryFile and closes it when the stream is closed.
* This extends FileInputStream just because {@link #createInputStream} returns
* a FileInputStream. All the FileInputStream methods are
* overridden to use the MemoryFile instead.
*/
private static class AutoCloseMemoryFileInputStream extends FileInputStream {
private ParcelFileDescriptor mParcelFd;
private MemoryFile mFile;
private InputStream mStream;
public AutoCloseMemoryFileInputStream(ParcelFileDescriptor fd, int length)
throws IOException {
super(fd.getFileDescriptor());
mParcelFd = fd;
mFile = new MemoryFile(fd.getFileDescriptor(), length, "r");
mStream = mFile.getInputStream();
}
@Override
public int available() throws IOException {
return mStream.available();
}
@Override
public void close() throws IOException {
mParcelFd.close(); // must close ParcelFileDescriptor, not just the file descriptor,
// since it could be a subclass of ParcelFileDescriptor.
// E.g. ContentResolver.ParcelFileDescriptorInner.close() releases
// a content provider
mFile.close(); // to unmap the memory file from the address space.
mStream.close(); // doesn't actually do anything
}
@Override
public FileChannel getChannel() {
return null;
}
@Override
public int read() throws IOException {
return mStream.read();
}
@Override
public int read(byte[] buffer, int offset, int count) throws IOException {
return mStream.read(buffer, offset, count);
}
@Override
public int read(byte[] buffer) throws IOException {
return mStream.read(buffer);
}
@Override
public long skip(long count) throws IOException {
return mStream.skip(count);
}
}
/**
* An OutputStream you can create on a ParcelFileDescriptor, which will
* take care of calling {@link ParcelFileDescriptor#close
@@ -345,4 +421,16 @@ public class AssetFileDescriptor implements Parcelable {
return new AssetFileDescriptor[size];
}
};
/**
* Creates an AssetFileDescriptor from a memory file.
*
* @hide
*/
public static AssetFileDescriptor fromMemoryFile(MemoryFile memoryFile)
throws IOException {
ParcelFileDescriptor fd = memoryFile.getParcelFileDescriptor();
return new AssetFileDescriptor(fd, 0, memoryFile.length());
}
}

117
core/java/android/os/MemoryFile.java
View File

@@ -37,9 +37,14 @@ public class MemoryFile
{
private static String TAG = "MemoryFile";
// mmap(2) protection flags from <sys/mman.h>
private static final int PROT_READ = 0x1;
private static final int PROT_WRITE = 0x2;
private static native FileDescriptor native_open(String name, int length) throws IOException;
// returns memory address for ashmem region
private static native int native_mmap(FileDescriptor fd, int length) throws IOException;
private static native int native_mmap(FileDescriptor fd, int length, int mode)
throws IOException;
private static native void native_munmap(int addr, int length) throws IOException;
private static native void native_close(FileDescriptor fd);
private static native int native_read(FileDescriptor fd, int address, byte[] buffer,
@@ -47,14 +52,16 @@ public class MemoryFile
private static native void native_write(FileDescriptor fd, int address, byte[] buffer,
int srcOffset, int destOffset, int count, boolean isUnpinned) throws IOException;
private static native void native_pin(FileDescriptor fd, boolean pin) throws IOException;
private static native boolean native_is_ashmem_region(FileDescriptor fd) throws IOException;
private FileDescriptor mFD; // ashmem file descriptor
private int mAddress; // address of ashmem memory
private int mLength; // total length of our ashmem region
private boolean mAllowPurging = false; // true if our ashmem region is unpinned
private final boolean mOwnsRegion; // false if this is a ref to an existing ashmem region
/**
* MemoryFile constructor.
* Allocates a new ashmem region. The region is initially not purgable.
*
* @param name optional name for the file (can be null).
* @param length of the memory file in bytes.
@@ -63,11 +70,43 @@ public class MemoryFile
public MemoryFile(String name, int length) throws IOException {
mLength = length;
mFD = native_open(name, length);
mAddress = native_mmap(mFD, length);
mAddress = native_mmap(mFD, length, PROT_READ | PROT_WRITE);
mOwnsRegion = true;
}
/**
* Closes and releases all resources for the memory file.
* Creates a reference to an existing memory file. Changes to the original file
* will be available through this reference.
* Calls to {@link #allowPurging(boolean)} on the returned MemoryFile will fail.
*
* @param fd File descriptor for an existing memory file, as returned by
* {@link #getFileDescriptor()}. This file descriptor will be closed
* by {@link #close()}.
* @param length Length of the memory file in bytes.
* @param mode File mode. Currently only "r" for read-only access is supported.
* @throws NullPointerException if <code>fd</code> is null.
* @throws IOException If <code>fd</code> does not refer to an existing memory file,
* or if the file mode of the existing memory file is more restrictive
* than <code>mode</code>.
*
* @hide
*/
public MemoryFile(FileDescriptor fd, int length, String mode) throws IOException {
if (fd == null) {
throw new NullPointerException("File descriptor is null.");
}
if (!isMemoryFile(fd)) {
throw new IllegalArgumentException("Not a memory file.");
}
mLength = length;
mFD = fd;
mAddress = native_mmap(mFD, length, modeToProt(mode));
mOwnsRegion = false;
}
/**
* Closes the memory file. If there are no other open references to the memory
* file, it will be deleted.
*/
public void close() {
deactivate();
@@ -76,7 +115,14 @@ public class MemoryFile
}
}
private void deactivate() {
/**
* Unmaps the memory file from the process's memory space, but does not close it.
* After this method has been called, read and write operations through this object
* will fail, but {@link #getFileDescriptor()} will still return a valid file descriptor.
*
* @hide
*/
public void deactivate() {
if (!isDeactivated()) {
try {
native_munmap(mAddress, mLength);
@@ -135,6 +181,9 @@ public class MemoryFile
* @return previous value of allowPurging
*/
synchronized public boolean allowPurging(boolean allowPurging) throws IOException {
if (!mOwnsRegion) {
throw new IOException("Only the owner can make ashmem regions purgable.");
}
boolean oldValue = mAllowPurging;
if (oldValue != allowPurging) {
native_pin(mFD, !allowPurging);
@@ -210,6 +259,64 @@ public class MemoryFile
native_write(mFD, mAddress, buffer, srcOffset, destOffset, count, mAllowPurging);
}
/**
* Gets a ParcelFileDescriptor for the memory file. See {@link #getFileDescriptor()}
* for caveats. This must be here to allow classes outside <code>android.os</code< to
* make ParcelFileDescriptors from MemoryFiles, as
* {@link ParcelFileDescriptor#ParcelFileDescriptor(FileDescriptor)} is package private.
*
*
* @return The file descriptor owned by this memory file object.
* The file descriptor is not duplicated.
* @throws IOException If the memory file has been closed.
*
* @hide
*/
public ParcelFileDescriptor getParcelFileDescriptor() throws IOException {
return new ParcelFileDescriptor(getFileDescriptor());
}
/**
* Gets a FileDescriptor for the memory file. Note that this file descriptor
* is only safe to pass to {@link #MemoryFile(FileDescriptor,int)}). It
* should not be used with file descriptor operations that expect a file descriptor
* for a normal file.
*
* The returned file descriptor is not duplicated.
*
* @throws IOException If the memory file has been closed.
*
* @hide
*/
public FileDescriptor getFileDescriptor() throws IOException {
return mFD;
}
/**
* Checks whether the given file descriptor refers to a memory file.
*
* @throws IOException If <code>fd</code> is not a valid file descriptor.
*
* @hide
*/
public static boolean isMemoryFile(FileDescriptor fd) throws IOException {
return native_is_ashmem_region(fd);
}
/**
* Converts a file mode string to a <code>prot</code> value as expected by
* native_mmap().
*
* @throws IllegalArgumentException if the file mode is invalid.
*/
private static int modeToProt(String mode) {
if ("r".equals(mode)) {
return PROT_READ;
} else {
throw new IllegalArgumentException("Unsupported file mode: '" + mode + "'");
}
}
private class MemoryInputStream extends InputStream {
private int mMark = 0;