เข้าถึงเอกสารและไฟล์อื่นๆ จากพื้นที่เก็บข้อมูลที่ใช้ร่วมกัน

จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ

// Request code for creating a PDF document. const val CREATE_FILE = 1  private fun createFile(pickerInitialUri: Uri) {     val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {         addCategory(Intent.CATEGORY_OPENABLE)         type = "application/pdf"         putExtra(Intent.EXTRA_TITLE, "invoice.pdf")          // Optionally, specify a URI for the directory that should be opened in         // the system file picker before your app creates the document.         putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)     }     startActivityForResult(intent, CREATE_FILE) }

// Request code for creating a PDF document. private static final int CREATE_FILE = 1;  private void createFile(Uri pickerInitialUri) {     Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);     intent.addCategory(Intent.CATEGORY_OPENABLE);     intent.setType("application/pdf");     intent.putExtra(Intent.EXTRA_TITLE, "invoice.pdf");      // Optionally, specify a URI for the directory that should be opened in     // the system file picker when your app creates the document.     intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri);      startActivityForResult(intent, CREATE_FILE); }

// Request code for selecting a PDF document. const val PICK_PDF_FILE = 2  fun openFile(pickerInitialUri: Uri) {     val intent = Intent(Intent.ACTION_OPEN_DOCUMENT).apply {         addCategory(Intent.CATEGORY_OPENABLE)         type = "application/pdf"          // Optionally, specify a URI for the file that should appear in the         // system file picker when it loads.         putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)     }      startActivityForResult(intent, PICK_PDF_FILE) }

// Request code for selecting a PDF document. private static final int PICK_PDF_FILE = 2;  private void openFile(Uri pickerInitialUri) {     Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);     intent.addCategory(Intent.CATEGORY_OPENABLE);     intent.setType("application/pdf");      // Optionally, specify a URI for the file that should appear in the     // system file picker when it loads.     intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri);      startActivityForResult(intent, PICK_PDF_FILE); }

fun openDirectory(pickerInitialUri: Uri) {     // Choose a directory using the system's file picker.     val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {         // Optionally, specify a URI for the directory that should be opened in         // the system file picker when it loads.         putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)     }      startActivityForResult(intent, your-request-code) }

public void openDirectory(Uri uriToLoad) {     // Choose a directory using the system's file picker.     Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);      // Optionally, specify a URI for the directory that should be opened in     // the system file picker when it loads.     intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, uriToLoad);      startActivityForResult(intent, your-request-code); }

override fun onActivityResult(         requestCode: Int, resultCode: Int, resultData: Intent?) {     if (requestCode == your-request-code             && resultCode == Activity.RESULT_OK) {         // The result data contains a URI for the document or directory that         // the user selected.         resultData?.data?.also { uri ->             // Perform operations on the document using its URI.         }     } }

@Override public void onActivityResult(int requestCode, int resultCode,         Intent resultData) {     if (requestCode == your-request-code             && resultCode == Activity.RESULT_OK) {         // The result data contains a URI for the document or directory that         // the user selected.         Uri uri = null;         if (resultData != null) {             uri = resultData.getData();             // Perform operations on the document using its URI.         }     } }

val contentResolver = applicationContext.contentResolver  val takeFlags: Int = Intent.FLAG_GRANT_READ_URI_PERMISSION or         Intent.FLAG_GRANT_WRITE_URI_PERMISSION // Check for the freshest data. contentResolver.takePersistableUriPermission(uri, takeFlags)

final int takeFlags = intent.getFlags()             & (Intent.FLAG_GRANT_READ_URI_PERMISSION             | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); // Check for the freshest data. getContentResolver().takePersistableUriPermission(uri, takeFlags);

val contentResolver = applicationContext.contentResolver  fun dumpImageMetaData(uri: Uri) {      // The query, because it only applies to a single document, returns only     // one row. There's no need to filter, sort, or select fields,     // because we want all fields for one document.     val cursor: Cursor? = contentResolver.query(             uri, null, null, null, null, null)      cursor?.use {         // moveToFirst() returns false if the cursor has 0 rows. Very handy for         // "if there's anything to look at, look at it" conditionals.         if (it.moveToFirst()) {              // Note it's called "Display Name". This is             // provider-specific, and might not necessarily be the file name.             val displayName: String =                     it.getString(it.getColumnIndex(OpenableColumns.DISPLAY_NAME))             Log.i(TAG, "Display Name: $displayName")              val sizeIndex: Int = it.getColumnIndex(OpenableColumns.SIZE)             // If the size is unknown, the value stored is null. But because an             // int can't be null, the behavior is implementation-specific,             // and 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.             val size: String = if (!it.isNull(sizeIndex)) {                 // Technically the column stores an int, but cursor.getString()                 // will do the conversion automatically.                 it.getString(sizeIndex)             } else {                 "Unknown"             }             Log.i(TAG, "Size: $size")         }     } }

public void dumpImageMetaData(Uri uri) {      // The query, because it only applies to a single document, returns only     // one row. There's no need to filter, sort, or select fields,     // because 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 because an             // int can't be null, the behavior is implementation-specific,             // and 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();     } }

val contentResolver = applicationContext.contentResolver  @Throws(IOException::class) private fun getBitmapFromUri(uri: Uri): Bitmap {     val parcelFileDescriptor: ParcelFileDescriptor =             contentResolver.openFileDescriptor(uri, "r")     val fileDescriptor: FileDescriptor = parcelFileDescriptor.fileDescriptor     val image: Bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor)     parcelFileDescriptor.close()     return image }

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; }

val contentResolver = applicationContext.contentResolver  @Throws(IOException::class) private fun readTextFromUri(uri: Uri): String {     val stringBuilder = StringBuilder()     contentResolver.openInputStream(uri)?.use { inputStream ->         BufferedReader(InputStreamReader(inputStream)).use { reader ->             var line: String? = reader.readLine()             while (line != null) {                 stringBuilder.append(line)                 line = reader.readLine()             }         }     }     return stringBuilder.toString() }

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

val contentResolver = applicationContext.contentResolver  private fun alterDocument(uri: Uri) {     try {         contentResolver.openFileDescriptor(uri, "w")?.use {             FileOutputStream(it.fileDescriptor).use {                 it.write(                     ("Overwritten at ${System.currentTimeMillis()}\n")                         .toByteArray()                 )             }         }     } catch (e: FileNotFoundException) {         e.printStackTrace()     } catch (e: IOException) {         e.printStackTrace()     } }

private void alterDocument(Uri uri) {     try {         ParcelFileDescriptor pfd = getActivity().getContentResolver().                 openFileDescriptor(uri, "w");         FileOutputStream fileOutputStream =                 new FileOutputStream(pfd.getFileDescriptor());         fileOutputStream.write(("Overwritten at " + System.currentTimeMillis() +                 "\n").getBytes());         // Let the document provider know you're done by closing the stream.         fileOutputStream.close();         pfd.close();     } catch (FileNotFoundException e) {         e.printStackTrace();     } catch (IOException e) {         e.printStackTrace();     } }

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri)

DocumentsContract.deleteDocument(applicationContext.contentResolver, uri);

private fun isVirtualFile(uri: Uri): Boolean {     if (!DocumentsContract.isDocumentUri(this, uri)) {         return false     }      val cursor: Cursor? = contentResolver.query(             uri,             arrayOf(DocumentsContract.Document.COLUMN_FLAGS),             null,             null,             null     )      val flags: Int = cursor?.use {         if (cursor.moveToFirst()) {             cursor.getInt(0)         } else {             0         }     } ?: 0      return flags and DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT != 0 }

private boolean isVirtualFile(Uri uri) {     if (!DocumentsContract.isDocumentUri(this, uri)) {         return false;     }      Cursor cursor = getContentResolver().query(         uri,         new String[] { DocumentsContract.Document.COLUMN_FLAGS },         null, null, null);      int flags = 0;     if (cursor.moveToFirst()) {         flags = cursor.getInt(0);     }     cursor.close();      return (flags & DocumentsContract.Document.FLAG_VIRTUAL_DOCUMENT) != 0; }

@Throws(IOException::class) private fun getInputStreamForVirtualFile(         uri: Uri, mimeTypeFilter: String): InputStream {      val openableMimeTypes: Array<String>? =             contentResolver.getStreamTypes(uri, mimeTypeFilter)      return if (openableMimeTypes?.isNotEmpty() == true) {         contentResolver                 .openTypedAssetFileDescriptor(uri, openableMimeTypes[0], null)                 .createInputStream()     } else {         throw FileNotFoundException()     } }

private InputStream getInputStreamForVirtualFile(Uri uri, String mimeTypeFilter)     throws IOException {      ContentResolver resolver = getContentResolver();      String[] openableMimeTypes = resolver.getStreamTypes(uri, mimeTypeFilter);      if (openableMimeTypes == null ||         openableMimeTypes.length < 1) {         throw new FileNotFoundException();     }      return resolver         .openTypedAssetFileDescriptor(uri, openableMimeTypes[0], null)         .createInputStream(); }