android存储访问框架StorageAccessFramework

private static final int READ_REQUEST_CODE = 42;
...
/**
 * Fires an intent to spin up the "file chooser" UI and select an image.
 */
public void performFileSearch() {
 // ACTION_OPEN_DOCUMENT is the intent to choose a file via the system's file
 // browser.
 Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
 // Filter to only show results that can be "opened", such as a
 // file (as opposed to a list of contacts or timezones)
 intent.addCategory(Intent.CATEGORY_OPENABLE);
 // Filter to show only images, using the image MIME data type.
 // If one wanted to search for ogg vorbis files, the type would be "audio/ogg".
 // To search for all documents available via installed storage providers,
 // it would be "*/*".
 intent.setType("image/*");
 startActivityForResult(intent, READ_REQUEST_CODE);
}

@Override
public void onActivityResult(int requestCode, int resultCode,
 Intent resultData) {
 // The ACTION_OPEN_DOCUMENT intent was sent with the request code
 // READ_REQUEST_CODE. If the request code seen here doesn't match, it's the
 // response to some other intent, and the code below shouldn't run at all.
 if (requestCode == READ_REQUEST_CODE && resultCode == Activity.RESULT_OK) {
 // The document selected by the user won't be returned in the intent.
 // Instead, a URI to that document will be contained in the return intent
 // provided to this method as a parameter.
 // Pull that URI using resultData.getData().
 Uri uri = null;
 if (resultData != null) {
 uri = resultData.getData();
 Log.i(TAG, "Uri: " + uri.toString());
 showImage(uri);
 }
 }
}

public void dumpImageMetaData(Uri uri) {
 // The query, since it only applies to a single document, will only return
 // one row. There's no need to filter, sort, or select fields, since we want
 // all fields for one document.
 Cursor cursor = getActivity().getContentResolver()
 .query(uri, null, null, null, null, null);
 try {
 // moveToFirst() returns false if the cursor has 0 rows. Very handy for
 // "if there's anything to look at, look at it" conditionals.
 if (cursor != null && cursor.moveToFirst()) {
 // Note it's called "Display Name". This is
 // provider-specific, and might not necessarily be the file name.
 String displayName = cursor.getString(
 cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME));
 Log.i(TAG, "Display Name: " + displayName);
 int sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
 // If the size is unknown, the value stored is null. But since an
 // int can't be null in Java, the behavior is implementation-specific,
 // which is just a fancy term for "unpredictable". So as
 // a rule, check if it's null before assigning to an int. This will
 // happen often: The storage API allows for remote files, whose
 // size might not be locally known.
 String size = null;
 if (!cursor.isNull(sizeIndex)) {
 // Technically the column stores an int, but cursor.getString()
 // will do the conversion automatically.
 size = cursor.getString(sizeIndex);
 } else {
 size = "Unknown";
 }
 Log.i(TAG, "Size: " + size);
 }
 } finally {
 cursor.close();
 }
}

private Bitmap getBitmapFromUri(Uri uri) throws IOException {
 ParcelFileDescriptor parcelFileDescriptor =
 getContentResolver().openFileDescriptor(uri, "r");
 FileDescriptor fileDescriptor = parcelFileDescriptor.getFileDescriptor();
 Bitmap image = BitmapFactory.decodeFileDescriptor(fileDescriptor);
 parcelFileDescriptor.close();
 return image;

private String readTextFromUri(Uri uri) throws IOException {
 InputStream inputStream = getContentResolver().openInputStream(uri);
 BufferedReader reader = new BufferedReader(new InputStreamReader(
 inputStream));
 StringBuilder stringBuilder = new StringBuilder();
 String line;
 while ((line = reader.readLine()) != null) {
 stringBuilder.append(line);
 }
 fileInputStream.close();
 parcelFileDescriptor.close();
 return stringBuilder.toString();
}

// Here are some examples of how you might call this method.
// The first parameter is the MIME type, and the second parameter is the name
// of the file you are creating:
//
// createFile("text/plain", "foobar.txt");
// createFile("image/png", "mypicture.png");
// Unique request code.
private static final int WRITE_REQUEST_CODE = 43;
...
private void createFile(String mimeType, String fileName) {
 Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
 // Filter to only show results that can be "opened", such as
 // a file (as opposed to a list of contacts or timezones).
 intent.addCategory(Intent.CATEGORY_OPENABLE);
 // Create a file with the requested MIME type.
 intent.setType(mimeType);
 intent.putExtra(Intent.EXTRA_TITLE, fileName);
 startActivityForResult(intent, WRITE_REQUEST_CODE);
}

 ...
 
 ....
 
 
 
 
 
 

@Override
public Cursor queryRoots(String[] projection) throws FileNotFoundException {
 // Create a cursor with either the requested fields, or the default
 // projection if "projection" is null.
 final MatrixCursor result =
 new MatrixCursor(resolveRootProjection(projection));
 // If user is not logged in, return an empty root cursor. This removes our
 // provider from the list entirely.
 if (!isUserLoggedIn()) {
 return result;
 }
 // It's possible to have multiple roots (e.g. for multiple accounts in the
 // same app) -- just add multiple cursor rows.
 // Construct one row for a root called "MyCloud".
 final MatrixCursor.RowBuilder row = result.newRow();
 row.add(Root.COLUMN_ROOT_ID, ROOT);
 row.add(Root.COLUMN_SUMMARY, getContext().getString(R.string.root_summary));
 // FLAG_SUPPORTS_CREATE means at least one directory under the root supports
 // creating documents. FLAG_SUPPORTS_RECENTS means your application's most
 // recently used documents will show up in the "Recents" category.
 // FLAG_SUPPORTS_SEARCH allows users to search all documents the application
 // shares.
 row.add(Root.COLUMN_FLAGS, Root.FLAG_SUPPORTS_CREATE |
 Root.FLAG_SUPPORTS_RECENTS |
 Root.FLAG_SUPPORTS_SEARCH);
 // COLUMN_TITLE is the root title (e.g. Gallery, Drive).
 row.add(Root.COLUMN_TITLE, getContext().getString(R.string.title));
 // This document id cannot change once it's shared.
 row.add(Root.COLUMN_DOCUMENT_ID, getDocIdForFile(mBaseDir));
 // The child MIME types are used to filter the roots and only present to the
 // user roots that contain the desired type somewhere in their file hierarchy.
 row.add(Root.COLUMN_MIME_TYPES, getChildMimeTypes(mBaseDir));
 row.add(Root.COLUMN_AVAILABLE_BYTES, mBaseDir.getFreeSpace());
 row.add(Root.COLUMN_ICON, R.drawable.ic_launcher);
 return result;
}

@Override
public Cursor queryChildDocuments(String parentDocumentId, String[] projection,
 String sortOrder) throws FileNotFoundException {
 final MatrixCursor result = new
 MatrixCursor(resolveDocumentProjection(projection));
 final File parent = getFileForDocId(parentDocumentId);
 for (File file : parent.listFiles()) {
 // Adds the file's display name, MIME type, size, and so on.
 includeFile(result, null, file);
 }
 return result;
}

@Override
public Cursor queryDocument(String documentId, String[] projection) throws
 FileNotFoundException {
 // Create a cursor with the requested projection, or the default projection.
 final MatrixCursor result = new
 MatrixCursor(resolveDocumentProjection(projection));
 includeFile(result, documentId, null);
 return result;
}