我注意到这个问题再次引起了人们的兴趣。我很高兴地说，我确实找到了解决问题的方法。我进行了广泛的在线研究并找到了一些源代码文件（尽管很抱歉我不记得在哪里找到它们）解决了我的问题
Android 4.4 及更高版本的问题在于，您需要通过存储访问框架获得额外权限，以便第三方应用删除/修改外部 SD 卡文件。
为了获得这些权限，您需要获得文档的 URI 或其父文件的（目录）URI 之一。为此，您需要打开 Android 的内置文件浏览器。用户最好通过文件浏览器选择 SD 卡根目录，以便您的应用可以修改/删除 SD 卡上的任何文件。
为此，您可以遵循以下代码：
private int REQUEST_CODE = 42;
private void getSDCardAccess(){
Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
startActivityForResult(intent, REQUEST_CODE);
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent resultData) {
if (resultCode == RESULT_OK) {
Uri treeUri = resultData.getData();
DocumentFile pickedDir = DocumentFile.fromTreeUri(this, treeUri);
getContentResolver().takePersistableUriPermission(treeUri,
Intent.FLAG_GRANT_READ_URI_PERMISSION |
Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
if(shrdPref == null){
shrdPref = getSharedPreferences(PREF_MAIN_FILE, MODE_PRIVATE);
}
//Takes the access so that we can use it again after the app reopens
shrdPref.edit().putString(KEY_SDCARDSTORAGE, treeUri.toString()).apply();
}
}
您还需要文件的“文档文件”才能修改和删除文件。
以下代码 sn-ps 可以帮助您做到这一点，以及使用文档文件方法检测文件/目录是否可写...
（我知道它有很多代码，其中大部分来自另一个来源。我真的很遗憾忘记了我从哪里得到它，因为它们确实值得很多赞誉）。您需要注意的函数是：isWritableNormalOrSAF()、deleteFile() 和可能的 copyFile()。请注意，这些功能需要大多数其他功能才能工作）
public static boolean isWritable(@NonNull final File file) {
boolean isExisting = file.exists();
try {
FileOutputStream output = new FileOutputStream(file, true);
try {
output.close();
}
catch (IOException e) {
// do nothing.
}
}
catch (FileNotFoundException e) {
return false;
}
boolean result = file.canWrite();
// Ensure that file is not created during this process.
if (!isExisting) {
// noinspection ResultOfMethodCallIgnored
file.delete();
}
return result;
}
public static boolean isWritableNormalOrSaf(@Nullable final File folder, Context context) {
// Verify that this is a directory.
Log.e("StorageHelper", "start");
if (folder == null || !folder.exists() || !folder.isDirectory()) {
Log.e("StorageHelper", "return 1");
return false;
}
// Find a non-existing file in this directory.
int i = 0;
File file;
do {
String fileName = "AugendiagnoseDummyFile" + (++i);
file = new File(folder, fileName);
//Log.e("StorageHelper", "file:" + fileName);
}
while (file.exists());
// First check regular writability
if (isWritable(file)) {
//Log.e("StorageHelper", "return 2 true");
return true;
}
// Next check SAF writability.
Log.e("StorageHelper", "start 2");
DocumentFile document;
try {
document = getDocumentFile(file, false, false, context);
}
catch (Exception e) {
//Log.e("StorageHelper", "return 3 exception");
return false;
}
if (document == null) {
//Log.e("StorageHelper", "return 4 doc null");
return false;
}
// This should have created the file - otherwise something is wrong with access URL.
boolean result = document.canWrite() && file.exists();
// Ensure that the dummy file is not remaining.
document.delete();
//Log.e("StorageHelper", "return end");
return result;
}
public static boolean deleteFile(@NonNull final File file, Context context) {
// First try the normal deletion.
if (file.delete()) {
return true;
}
// Try with Storage Access Framework.
DocumentFile document = getDocumentFile(file, false, true, context);
return document != null && document.delete();
}
private static DocumentFile getDocumentFile(@NonNull final File file, final boolean isDirectory, final boolean createDirectories, Context context) {
SharedPreferences sharedPreferences = context.getSharedPreferences(PREF_MAIN_FILE, Context.MODE_PRIVATE);
String uriString = sharedPreferences.getString(KEY_SDCARDSTORAGE, null);
if(uriString == null){
return null;
}
Uri treeUri = Uri.parse(uriString);
String fullPath;
try {
fullPath = file.getCanonicalPath();
}
catch (IOException e) {
return null;
}
String baseFolder = null;
// First try to get the base folder via unofficial StorageVolume API from the URIs.
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.O) {
StorageManager storageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
StorageVolume volume = storageManager.getStorageVolume(file);
String uuid = volume.getUuid();
String volumeId = getVolumeIdFromTreeUri(treeUri);
if (uuid.equals(volumeId)) {
// Use parcel to get the hidden path field from StorageVolume
Parcel parcel = Parcel.obtain();
volume.writeToParcel(parcel, 0);
parcel.setDataPosition(0);
parcel.readString();
parcel.readInt();
String volumeBasePath = parcel.readString();
parcel.recycle();
baseFolder = getFullPathFromTreeUri(treeUri, volumeBasePath);
}
}
else {
// Use Java Reflection to access hidden methods from StorageVolume
String treeBase = getFullPathFromTreeUri(treeUri, getVolumePath(getVolumeIdFromTreeUri(treeUri), context));
if (treeBase != null && fullPath.startsWith(treeBase)) {
treeUri = treeUri;
baseFolder = treeBase;
}
}
if (baseFolder == null) {
// Alternatively, take root folder from device and assume that base URI works.
baseFolder = getExtSdCardFolder(file, context);
}
if (baseFolder == null) {
return null;
}
String relativePath = fullPath.substring(baseFolder.length() + 1);
// start with root of SD card and then parse through document tree.
DocumentFile document = DocumentFile.fromTreeUri(context, treeUri);
String[] parts = relativePath.split("\\/");
for (int i = 0; i < parts.length; i++) {
DocumentFile nextDocument = document.findFile(parts[i]);
if (nextDocument == null) {
if (i < parts.length - 1) {
if (createDirectories) {
nextDocument = document.createDirectory(parts[i]);
}
else {
return null;
}
}
else if (isDirectory) {
nextDocument = document.createDirectory(parts[i]);
}
else {
nextDocument = document.createFile("image", parts[i]);
}
}
document = nextDocument;
}
return document;
}
@Nullable
private static String getFullPathFromTreeUri(@Nullable final Uri treeUri, final String volumeBasePath) {
if (treeUri == null) {
return null;
}
if (volumeBasePath == null) {
return File.separator;
}
String volumePath = volumeBasePath;
if (volumePath.endsWith(File.separator)) {
volumePath = volumePath.substring(0, volumePath.length() - 1);
}
String documentPath = getDocumentPathFromTreeUri(treeUri);
if (documentPath.endsWith(File.separator)) {
documentPath = documentPath.substring(0, documentPath.length() - 1);
}
if (documentPath.length() > 0) {
if (documentPath.startsWith(File.separator)) {
return volumePath + documentPath;
}
else {
return volumePath + File.separator + documentPath;
}
}
else {
return volumePath;
}
}
private static String getVolumeIdFromTreeUri(final Uri treeUri) {
final String docId = DocumentsContract.getTreeDocumentId(treeUri);
final String[] split = docId.split(":");
if (split.length > 0) {
return split[0];
}
else {
return null;
}
}
private static final String PRIMARY_VOLUME_NAME = "primary";
private static String getVolumePath(final String volumeId, Context context) {
try {
StorageManager storageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
Class<?> storageVolumeClazz = Class.forName("android.os.storage.StorageVolume");
Method getVolumeList = storageManager.getClass().getMethod("getVolumeList");
Method getUuid = storageVolumeClazz.getMethod("getUuid");
Method getPath = storageVolumeClazz.getMethod("getPath");
Method isPrimary = storageVolumeClazz.getMethod("isPrimary");
Object result = getVolumeList.invoke(storageManager);
final int length = Array.getLength(result);
for (int i = 0; i < length; i++) {
Object storageVolumeElement = Array.get(result, i);
String uuid = (String) getUuid.invoke(storageVolumeElement);
Boolean primary = (Boolean) isPrimary.invoke(storageVolumeElement);
// primary volume?
if (primary && PRIMARY_VOLUME_NAME.equals(volumeId)) {
return (String) getPath.invoke(storageVolumeElement);
}
// other volumes?
if (uuid != null) {
if (uuid.equals(volumeId)) {
return (String) getPath.invoke(storageVolumeElement);
}
}
}
// not found.
return null;
}
catch (Exception ex) {
return null;
}
}
private static String getDocumentPathFromTreeUri(final Uri treeUri) {
final String docId = DocumentsContract.getTreeDocumentId(treeUri);
final String[] split = docId.split(":");
if ((split.length >= 2) && (split[1] != null)) {
return split[1];
}
else {
return File.separator;
}
}
public static String getExtSdCardFolder(@NonNull final File file, Context context) {
String[] extSdPaths = getExtSdCardPaths(context);
try {
for (String extSdPath : extSdPaths) {
if (file.getCanonicalPath().startsWith(extSdPath)) {
return extSdPath;
}
}
}
catch (IOException e) {
return null;
}
return null;
}
private static String[] getExtSdCardPaths(Context context) {
List<String> paths = new ArrayList<>();
for (File file : context.getExternalFilesDirs("external")) {
if (file != null && !file.equals(context.getExternalFilesDir("external"))) {
int index = file.getAbsolutePath().lastIndexOf("/Android/data");
if (index < 0) {
Log.w("StorageHelper", "Unexpected external file dir: " + file.getAbsolutePath());
}
else {
String path = file.getAbsolutePath().substring(0, index);
try {
path = new File(path).getCanonicalPath();
}
catch (IOException e) {
// Keep non-canonical path.
}
paths.add(path);
}
}
}
return paths.toArray(new String[paths.size()]);
}
public static boolean copyFile(@NonNull final File source, @NonNull final File target, Context context) {
FileInputStream inStream = null;
OutputStream outStream = null;
FileChannel inChannel = null;
FileChannel outChannel = null;
try {
inStream = new FileInputStream(source);
// First try the normal way
if (isWritable(target)) {
// standard way
outStream = new FileOutputStream(target);
inChannel = inStream.getChannel();
outChannel = ((FileOutputStream) outStream).getChannel();
inChannel.transferTo(0, inChannel.size(), outChannel);
}
else {
// Storage Access Framework
DocumentFile targetDocument = getDocumentFile(target, false, true, context);
if (targetDocument != null) {
outStream = context.getContentResolver().openOutputStream(targetDocument.getUri());
}
if (outStream != null) {
// Both for SAF and for Kitkat, write to output stream.
byte[] buffer = new byte[4096]; // MAGIC_NUMBER
int bytesRead;
while ((bytesRead = inStream.read(buffer)) != -1) {
outStream.write(buffer, 0, bytesRead);
}
}
}
}
catch (Exception e) {
Log.e("StorageHelper",
"Error when copying file from " + source.getAbsolutePath() + " to " + target.getAbsolutePath(), e);
return false;
}
finally {
try {
inStream.close();
}
catch (Exception e) {
// ignore exception
}
try {
outStream.close();
}
catch (Exception e) {
Log.e("StorageHelper", "OutStreamClose: " + e.toString());
// ignore exception
}
try {
((FileChannel) inChannel).close();
}
catch (Exception e) {
// ignore exception
}
try {
outChannel.close();
}
catch (Exception e) {
Log.e("StorageHelper", "OutChannelClose: " + e.toString());
// ignore exception
}
}
return true;
}
public static String getExtensionFromName(String fileName){
String extension = "";
int i = fileName.lastIndexOf('.');
if (i > 0) {
extension = fileName.substring(i+1);
}
return extension;
}