Edit: I have revised this answer to include the example code of approach I have initially referred to as "writing a specialized ContentProvider". This should fully satisfy requirements of the question. Probably makes the answer too big, but it has internal code dependencies now, so let's leave it as whole. The main point still holds true: use the ContentPrvder below if you want, but try to give file:// Uris to apps, that support them, unless you want to be blamed for someone's app crashing.
Original answer
I would stay away from Storage Access Framework as it is now. It's insufficiently backed by Google, and the support in apps is abysmal, making it is hard to tell between bugs in those apps and SAF itself. If you are confident enough (which really means "can use try-catch block better then average Android developer"), use Storage Access Framework yourself, but pass to others only good-old file:// paths.
You can use the following trick to get filesystem path from ParcelFileDescriptor (you can get it from ContentResolver by calling openFileDescriptor):
class FdCompat {
public static String getFdPath(ParcelFileDescriptor fd) {
final String resolved;
try {
final File procfsFdFile = new File("/proc/self/fd/" + fd.getFd());
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
// Returned name may be empty or "pipe:", "socket:", "(deleted)" etc.
resolved = Os.readlink(procfsFdFile.getAbsolutePath());
} else {
// Returned name is usually valid or empty, but may start from
// funny prefix if the file does not have a name
resolved = procfsFdFile.getCanonicalPath();
}
if (TextUtils.isEmpty(resolved) || resolved.charAt(0) != '/'
|| resolved.startsWith("/proc/") || resolved.startsWith("/fd/"))
return null;
} catch (IOException ioe) {
// This exception means, that given file DID have some name, but it is
// too long, some of symlinks in the path were broken or, most
// likely, one of it's directories is inaccessible for reading.
// Either way, it is almost certainly not a pipe.
return "";
} catch (Exception errnoe) {
// Actually ErrnoException, but base type avoids VerifyError on old versions
// This exception should be VERY rare and means, that the descriptor
// was made unavailable by some Unix magic.
return null;
}
return resolved;
}
}
You must be prepared, that the method above will return null (the file is a pipe or socket, which is perfectly legitimate) or an empty path (no read access to file's parent directory). If this happens copy the entire stream to some directory you can access.
Complete solution
If you really want to stick with content provider Uris, here you go. Take the code of ContentProvider below. Paste into your app (and register it in AndroidManifest). Use getShareableUri method below to convert received Storage Access Framework Uri into your own. Pass that Uri to other apps instead of the original Uri.
The code below is insecure (you can easily make it secure, but explaining that would expand the length of this answer beyond imagination). If you care, use file:// Uris—Linux file systems are widely considered secure enough.
Extending the solution below to provide arbitrary file descriptors without corresponding Uri is left as exercise for reader.
public class FdProvider extends ContentProvider {
private static final String ORIGINAL_URI = "o";
private static final String FD = "fd";
private static final String PATH = "p";
private static final Uri BASE_URI =
Uri.parse("content://com.example.fdhelper/");
// Create an Uri from some other Uri and (optionally) corresponding
// file descriptor (if you don't plan to close it until your process is dead).
public static Uri getShareableUri(@Nullable ParcelFileDescriptor fd,
Uri trueUri) {
String path = fd == null ? null : FdCompat.getFdPath(fd);
String uri = trueUri.toString();
Uri.Builder builder = BASE_URI.buildUpon();
if (!TextUtils.isEmpty(uri))
builder.appendQueryParameter(ORIGINAL_URI, uri);
if (fd != null && !TextUtils.isEmpty(path))
builder.appendQueryParameter(FD, String.valueOf(fd.getFd()))
.appendQueryParameter(PATH, path);
return builder.build();
}
public boolean onCreate() { return true; }
public ParcelFileDescriptor openFile(Uri uri, String mode)
throws FileNotFoundException {
String o = uri.getQueryParameter(ORIGINAL_URI);
String fd = uri.getQueryParameter(FD);
String path = uri.getQueryParameter(PATH);
if (TextUtils.isEmpty(o)) return null;
// offer the descriptor directly, if our process still has it
try {
if (!TextUtils.isEmpty(fd) && !TextUtils.isEmpty(path)) {
int intFd = Integer.parseInt(fd);
ParcelFileDescriptor desc = ParcelFileDescriptor.fromFd(intFd);
if (intFd >= 0 && path.equals(FdCompat.getFdPath(desc))) {
return desc;
}
}
} catch (RuntimeException | IOException ignore) {}
// otherwise just forward the call
try {
Uri trueUri = Uri.parse(o);
return getContext().getContentResolver()
.openFileDescriptor(trueUri, mode);
}
catch (RuntimeException ignore) {}
throw new FileNotFoundException();
}
// all other calls are forwarded the same way as above
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
String o = uri.getQueryParameter(ORIGINAL_URI);
if (TextUtils.isEmpty(o)) return null;
try {
Uri trueUri = Uri.parse(o);
return getContext().getContentResolver().query(trueUri, projection,
selection, selectionArgs, sortOrder);
} catch (RuntimeException ignore) {}
return null;
}
public String getType(Uri uri) {
String o = uri.getQueryParameter(ORIGINAL_URI);
if (TextUtils.isEmpty(o)) return "*/*";
try {
Uri trueUri = Uri.parse(o);
return getContext().getContentResolver().getType(trueUri);
} catch (RuntimeException e) { return null; }
}
public Uri insert(Uri uri, ContentValues values) {
return null;
}
public int delete(Uri uri, String selection, String[] selectionArgs) {
return 0;
}
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) { return 0; }
}
new Intent(Intent.ACTION_VIEW, uri);– SlowUri; other apps do not have rights to use thatUri. – Fatherhood