Quando un'app vuole accedere a un file condiviso da un'altra app, l'app richiedente (il client) di solito invia una richiesta all'app che condivide i file (il server). Nella maggior parte dei casi, la richiesta avvia un Activity nell'app server che mostra i file che può condividere.
L'utente sceglie un file, dopodiché l'app server restituisce l'URI del contenuto del file all'app client.
Questa lezione illustra in che modo un'app client richiede un file da un'app server, riceve l'URI dei contenuti del file dall'app server e apre il file utilizzando l'URI dei contenuti.
Invia una richiesta per il file
Per richiedere un file dall'app server, l'app client chiama
startActivityForResult con un
Intent contenente l'azione come
ACTION_PICK e un tipo MIME che l'app client
è in grado di gestire.
Ad esempio, il seguente snippet di codice mostra come inviare un
Intent a un'app del server per avviare il
Activity descritto in Condivisione di un file:
Kotlin
class MainActivity : Activity() {
private lateinit var requestFileIntent: Intent
private lateinit var inputPFD: ParcelFileDescriptor
...
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
requestFileIntent = Intent(Intent.ACTION_PICK).apply {
type = "image/jpg"
}
...
}
...
private fun requestFile() {
/**
* When the user requests a file, send an Intent to the
* server app.
* files.
*/
startActivityForResult(requestFileIntent, 0)
...
}
...
}
Java
public class MainActivity extends Activity {
private Intent requestFileIntent;
private ParcelFileDescriptor inputPFD;
...
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
requestFileIntent = new Intent(Intent.ACTION_PICK);
requestFileIntent.setType("image/jpg");
...
}
...
protected void requestFile() {
/**
* When the user requests a file, send an Intent to the
* server app.
* files.
*/
startActivityForResult(requestFileIntent, 0);
...
}
...
}
Accedere al file richiesto
L'app server invia l'URI dei contenuti del file all'app client in un
Intent. Questo elemento Intent viene trasmesso all'app client
nel suo override di onActivityResult(). Quando
l'app client dispone dell'URI dei contenuti del file, può accedere al file recuperando
FileDescriptor.
La sicurezza dei file viene mantenuta in questo processo solo se analizzi correttamente l'URI dei contenuti ricevuto dall'app client. Durante l'analisi dei contenuti, devi assicurarti che questo URI non rimandi a elementi esterni alla directory desiderata, in modo che non venga tentato alcun percorso di attraversamento. Solo l'app client deve accedere al file e solo per le autorizzazioni concesse dall'app del server. Le autorizzazioni sono temporanee; pertanto, una volta completato lo stack di attività dell'app client, il file non è più accessibile all'esterno dell'app del server.
Lo snippet successivo mostra in che modo l'app client gestisce il
Intent inviato dall'app server e in che modo l'app client recupera
FileDescriptor utilizzando l'URI dei contenuti:
Kotlin
/*
* When the Activity of the app that hosts files sets a result and calls
* finish(), this method is invoked. The returned Intent contains the
* content URI of a selected file. The result code indicates if the
* selection worked or not.
*/
public override fun onActivityResult(requestCode: Int, resultCode: Int, returnIntent: Intent) {
// If the selection didn't work
if (resultCode != Activity.RESULT_OK) {
// Exit without doing anything else
return
}
// Get the file's content URI from the incoming Intent
returnIntent.data?.also { returnUri ->
/*
* Try to open the file for "read" access using the
* returned URI. If the file isn't found, write to the
* error log and return.
*/
inputPFD = try {
/*
* Get the content resolver instance for this context, and use it
* to get a ParcelFileDescriptor for the file.
*/
contentResolver.openFileDescriptor(returnUri, "r")
} catch (e: FileNotFoundException) {
e.printStackTrace()
Log.e("MainActivity", "File not found.")
return
}
// Get a regular file descriptor for the file
val fd = inputPFD.fileDescriptor
...
}
}
Java
/*
* When the Activity of the app that hosts files sets a result and calls
* finish(), this method is invoked. The returned Intent contains the
* content URI of a selected file. The result code indicates if the
* selection worked or not.
*/
@Override
public void onActivityResult(int requestCode, int resultCode,
Intent returnIntent) {
// If the selection didn't work
if (resultCode != RESULT_OK) {
// Exit without doing anything else
return;
} else {
// Get the file's content URI from the incoming Intent
Uri returnUri = returnIntent.getData();
/*
* Try to open the file for "read" access using the
* returned URI. If the file isn't found, write to the
* error log and return.
*/
try {
/*
* Get the content resolver instance for this context, and use it
* to get a ParcelFileDescriptor for the file.
*/
inputPFD = getContentResolver().openFileDescriptor(returnUri, "r");
} catch (FileNotFoundException e) {
e.printStackTrace();
Log.e("MainActivity", "File not found.");
return;
}
// Get a regular file descriptor for the file
FileDescriptor fd = inputPFD.getFileDescriptor();
...
}
}
Il metodo openFileDescriptor() restituisce un ParcelFileDescriptor per il file. Da questo oggetto, l'app client ottiene un oggetto FileDescriptor, che può utilizzare per leggere il file.
Per ulteriori informazioni correlate, fai riferimento a: