Wie Sie programmgesteuert verschieben , kopieren von Dateien auf SD?

Dies ist, wie ich endlich das Problem gelöst.

Ersten Aufruf eine Absicht, damit der Benutzer mit Schreibberechtigungen für die gesamte SD-Karte.

Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
        intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
        startActivityForResult(intent, 42);

Dann auf onActivityResult nehmen Schreibberechtigung.

public  void onActivityResult(int requestCode, int resultCode, Intent data) {      
          treeUri = data.getData();
        final int takeFlags = data.getFlags()
                    & (Intent.FLAG_GRANT_READ_URI_PERMISSION
                    | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
            getActivity().getContentResolver().takePersistableUriPermission(treeUri, takeFlags);

    }

- Und dies ist der code, den ich verwendet, um Dateien zu kopieren auf SD-Karte.

  public static boolean copy(File copy, String directory, Context con) {
  static FileInputStream inStream = null;
    static OutputStream outStream = null;
            DocumentFile dir= getDocumentFileIfAllowedToWrite(new File(directory), con);
            String mime = mime(copy.toURI().toString());
            DocumentFile copy1= dir.createFile(mime, copy.getName());
            try {
                inStream = new FileInputStream(copy);
                outStream =
                        con.getContentResolver().openOutputStream(copy1.getUri());
                byte[] buffer = new byte[16384];
                int bytesRead;
                while ((bytesRead = inStream.read(buffer)) != -1) {
                    outStream.write(buffer, 0, bytesRead);

                }


            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {

                    inStream.close();

                    outStream.close();


                    return true;


                } catch (IOException e) {
                    e.printStackTrace();
                }


            }

            return false;
        }

Der obige code verwendet die folgenden zwei Methoden.

getDocumentFileIfAllowedToWrite Methode gibt DocumentFile-wenn erlaubt ist zu schreiben.

public static DocumentFile getDocumentFileIfAllowedToWrite(File file, Context con) {

        List<UriPermission> permissionUris = con.getContentResolver().getPersistedUriPermissions();

        for (UriPermission permissionUri : permissionUris) {

            Uri treeUri = permissionUri.getUri();
            DocumentFile rootDocFile = DocumentFile.fromTreeUri(con, treeUri);
            String rootDocFilePath = FileUtil.getFullPathFromTreeUri(treeUri, con);

            if (file.getAbsolutePath().startsWith(rootDocFilePath)) {

                ArrayList<String> pathInRootDocParts = new ArrayList<String>();
                while (!rootDocFilePath.equals(file.getAbsolutePath())) {
                    pathInRootDocParts.add(file.getName());
                    file = file.getParentFile();
                }

                DocumentFile docFile = null;

                if (pathInRootDocParts.size() == 0) {
                    docFile = DocumentFile.fromTreeUri(con, rootDocFile.getUri());
                } else {
                    for (int i = pathInRootDocParts.size() - 1; i >= 0; i--) {
                        if (docFile == null) {
                            docFile = rootDocFile.findFile(pathInRootDocParts.get(i));
                        } else {
                            docFile = docFile.findFile(pathInRootDocParts.get(i));
                        }
                    }
                }
                if (docFile != null && docFile.canWrite()) {
                    return docFile;
                } else {
                    return null;
                }

            }
        }
        return null;
    }

- Und mime-Methode liefert den mime-Typ der Datei.

   public static String mime(String URI) {
    static String type;
            String extention = MimeTypeMap.getFileExtensionFromUrl(URI);
            if (extention != null) {
                type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extention);
            }
            return type;
        }

Ich getestet habe den obigen code mit Android Lollipop und Marshmallow.

EDIT: hier ist der link zu der FileUtils Klasse.