Importer des fichiers avec Cloud Storage sur Android

Cloud Storage for Firebase vous permet d'importer des fichiers rapidement et facilement dans un Cloud Storage bucket fourni et gérés par Firebase.

Remarque :Par défaut, un bucket Cloud Storage nécessite Firebase Authentication pour effectuer une action sur les données ou les fichiers du bucket. Vous pouvez remplacer Firebase Security Rules par Cloud Storage pour autoriser l'accès non authentifié. Comme Firebase et les paramètres App Engine application partage ce bucket. La configuration de l'accès public peut rendre a également importé App Engine fichiers accessibles publiquement. Veillez à nouveau à restreindre l'accès à votre bucket Cloud Storage lorsque vous configurez Authentication.

Remarque : Pour les projets du forfait Spark, Firebase bloque l'importation et l'hébergement de certains types de fichiers exécutables pour Windows (fichiers avec les extensions .exe, .dll et .bat), Android (extension .apk) et Apple (extension .ipa) par Cloud Storage for Firebase et Firebase Hosting. Ce règlement vise à empêcher l'utilisation abusive de notre plate-forme. Les projets du forfait Blaze ne sont pas concernés. Pour en savoir plus, consultez ces questions fréquentes.

Importer des fichiers

Pour importer un fichier dans Cloud Storage, vous devez d'abord créer une référence au chemin complet du fichier, y compris le nom du fichier.

Kotlin+KTX

// Create a storage reference from our app
val storageRef = storage.reference

// Create a reference to "mountains.jpg"
val mountainsRef = storageRef.child("mountains.jpg")

// Create a reference to 'images/mountains.jpg'
val mountainImagesRef = storageRef.child("images/mountains.jpg")

// While the file names are the same, the references point to different files
mountainsRef.name == mountainImagesRef.name // true
mountainsRef.path == mountainImagesRef.path // false
StorageActivity.kt

Java

// Create a storage reference from our app
StorageReference storageRef = storage.getReference();

// Create a reference to "mountains.jpg"
StorageReference mountainsRef = storageRef.child("mountains.jpg");

// Create a reference to 'images/mountains.jpg'
StorageReference mountainImagesRef = storageRef.child("images/mountains.jpg");

// While the file names are the same, the references point to different files
mountainsRef.getName().equals(mountainImagesRef.getName());    // true
mountainsRef.getPath().equals(mountainImagesRef.getPath());    // false
StorageActivity.java

Une fois que vous avez créé une référence appropriée, appelez la méthode putBytes(), putFile() ou putStream() pour importer le fichier. à Cloud Storage.

Vous ne pouvez pas importer de données faisant référence à la racine de votre Cloud Storage. Votre référence doit renvoyer vers une URL enfant.

Importer à partir des données en mémoire

La méthode putBytes() est le moyen le plus simple d'importer un dans Cloud Storage. putBytes() prend un byte[] et renvoie un UploadTask que vous pouvez utiliser pour gérer et surveiller l'état de l'importation.

Kotlin+KTX

// Get the data from an ImageView as bytes
imageView.isDrawingCacheEnabled = true
imageView.buildDrawingCache()
val bitmap = (imageView.drawable as BitmapDrawable).bitmap
val baos = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos)
val data = baos.toByteArray()

var uploadTask = mountainsRef.putBytes(data)
uploadTask.addOnFailureListener {
    // Handle unsuccessful uploads
}.addOnSuccessListener { taskSnapshot ->
    // taskSnapshot.metadata contains file metadata such as size, content-type, etc.
    // ...
}
StorageActivity.kt

Java

// Get the data from an ImageView as bytes
imageView.setDrawingCacheEnabled(true);
imageView.buildDrawingCache();
Bitmap bitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
byte[] data = baos.toByteArray();

UploadTask uploadTask = mountainsRef.putBytes(data);
uploadTask.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle unsuccessful uploads
    }
}).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
        // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc.
        // ...
    }
});
StorageActivity.java

Comme putBytes() accepte un byte[], votre application doit contenir l'intégralité le contenu d'un fichier en mémoire en une seule fois. Envisagez d'utiliser putStream() ou putFile() pour utiliser moins de mémoire.

Importer à partir d'un flux

La méthode putStream() est la méthode la plus polyvalente pour importer un dans Cloud Storage. putStream() prend un InputStream et renvoie un UploadTask que vous pouvez utiliser pour gérer et surveiller l'état de l'importation.

Kotlin+KTX

val stream = FileInputStream(File("path/to/images/rivers.jpg"))

uploadTask = mountainsRef.putStream(stream)
uploadTask.addOnFailureListener {
    // Handle unsuccessful uploads
}.addOnSuccessListener { taskSnapshot ->
    // taskSnapshot.metadata contains file metadata such as size, content-type, etc.
    // ...
}
StorageActivity.kt

Java

InputStream stream = new FileInputStream(new File("path/to/images/rivers.jpg"));

uploadTask = mountainsRef.putStream(stream);
uploadTask.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle unsuccessful uploads
    }
}).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
        // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc.
        // ...
    }
});
StorageActivity.java

Importer à partir d'un fichier local

Vous pouvez importer des fichiers locaux sur l'appareil, tels que des photos et des vidéos à partir du appareil photo, avec la méthode putFile(). putFile() prend un élément File et renvoie une UploadTask, qui vous permet de gérer et de surveiller l'état de l'importation.

Kotlin+KTX

var file = Uri.fromFile(File("path/to/images/rivers.jpg"))
val riversRef = storageRef.child("images/${file.lastPathSegment}")
uploadTask = riversRef.putFile(file)

// Register observers to listen for when the download is done or if it fails
uploadTask.addOnFailureListener {
    // Handle unsuccessful uploads
}.addOnSuccessListener { taskSnapshot ->
    // taskSnapshot.metadata contains file metadata such as size, content-type, etc.
    // ...
}
StorageActivity.kt

Java

Uri file = Uri.fromFile(new File("path/to/images/rivers.jpg"));
StorageReference riversRef = storageRef.child("images/"+file.getLastPathSegment());
uploadTask = riversRef.putFile(file);

// Register observers to listen for when the download is done or if it fails
uploadTask.addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle unsuccessful uploads
    }
}).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
        // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc.
        // ...
    }
});
StorageActivity.java

Obtenir une URL de téléchargement

Après avoir importé un fichier, vous pouvez obtenir une URL pour le télécharger en appelant la méthode getDownloadUrl() sur StorageReference:

Kotlin+KTX

val ref = storageRef.child("images/mountains.jpg")
uploadTask = ref.putFile(file)

val urlTask = uploadTask.continueWithTask { task ->
    if (!task.isSuccessful) {
        task.exception?.let {
            throw it
        }
    }
    ref.downloadUrl
}.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        val downloadUri = task.result
    } else {
        // Handle failures
        // ...
    }
}
StorageActivity.kt

Java

final StorageReference ref = storageRef.child("images/mountains.jpg");
uploadTask = ref.putFile(file);

Task<Uri> urlTask = uploadTask.continueWithTask(new Continuation<UploadTask.TaskSnapshot, Task<Uri>>() {
    @Override
    public Task<Uri> then(@NonNull Task<UploadTask.TaskSnapshot> task) throws Exception {
        if (!task.isSuccessful()) {
            throw task.getException();
        }

        // Continue with the task to get the download URL
        return ref.getDownloadUrl();
    }
}).addOnCompleteListener(new OnCompleteListener<Uri>() {
    @Override
    public void onComplete(@NonNull Task<Uri> task) {
        if (task.isSuccessful()) {
            Uri downloadUri = task.getResult();
        } else {
            // Handle failures
            // ...
        }
    }
});
StorageActivity.java

Ajouter des métadonnées de fichier

Vous pouvez également inclure des métadonnées lorsque vous importez des fichiers. Ces métadonnées contiennent des propriétés de métadonnées de fichier classiques telles que name, size, et contentType (communément appelé type MIME). La méthode putFile() déduit automatiquement le type MIME à partir de l'extension File, mais vous pouvez remplacer le type détecté automatiquement en spécifiant contentType dans les métadonnées. Si vous ne fournissez pas de contentType et que Cloud Storage ne peut pas déduire une valeur par défaut à partir de l'extension de fichier, Cloud Storage utilise application/octet-stream. Consultez la page Utiliser les métadonnées des fichiers. pour en savoir plus sur les métadonnées de fichiers.

Kotlin+KTX

// Create file metadata including the content type
var metadata = storageMetadata {
    contentType = "image/jpg"
}

// Upload the file and metadata
uploadTask = storageRef.child("images/mountains.jpg").putFile(file, metadata)
StorageActivity.kt

Java

// Create file metadata including the content type
StorageMetadata metadata = new StorageMetadata.Builder()
        .setContentType("image/jpg")
        .build();

// Upload the file and metadata
uploadTask = storageRef.child("images/mountains.jpg").putFile(file, metadata);
StorageActivity.java

Gérer les importations

Vous pouvez non seulement démarrer des importations, mais aussi les suspendre, les reprendre et les annuler à l'aide des commandes les méthodes pause(), resume() et cancel(). Mettre en veille et réactiver des événements génèrent respectivement des changements d'état de pause et progress. L'annulation d'une entraîne l'échec de l'importation et une erreur indiquant que l'importation a été annulée.

Kotlin+KTX

uploadTask = storageRef.child("images/mountains.jpg").putFile(file)

// Pause the upload
uploadTask.pause()

// Resume the upload
uploadTask.resume()

// Cancel the upload
uploadTask.cancel()
StorageActivity.kt

Java

uploadTask = storageRef.child("images/mountains.jpg").putFile(file);

// Pause the upload
uploadTask.pause();

// Resume the upload
uploadTask.resume();

// Cancel the upload
uploadTask.cancel();
StorageActivity.java

Surveiller la progression de l'importation

Vous pouvez ajouter des écouteurs pour gérer la réussite, l'échec, la progression ou les pauses dans votre tâche d'importation:

Type d'écouteur	Utilisation habituelle
OnProgressListener	Cet écouteur est appelé régulièrement lors du transfert de données et peut servir à renseigner un indicateur d'importation/téléchargement.
OnPausedListener	Cet écouteur est appelé à chaque fois que la tâche est mise en pause.
OnSuccessListener	Cet écouteur est appelé lorsque la tâche est terminée.
OnFailureListener	Cet écouteur est appelé à chaque fois que l'importation a échoué. Cela peut se produire en raison d'expirations de délais d'attente réseau, d'échecs d'autorisation ou si vous annulez la tâche.

OnFailureListener est appelé avec une instance Exception. Autre Les écouteurs sont appelés avec un objet UploadTask.TaskSnapshot. Cet objet est une vue immuable de la tâche au moment où l'événement s'est produit. Un UploadTask.TaskSnapshot contient les propriétés suivantes:

Propriété	Type	Description
getDownloadUrl	String	URL permettant de télécharger l'objet. Il s'agit d'une URL publique impossible à deviner, qui peut être partagée avec d'autres clients. Cette valeur est renseignée une fois l'importation terminée.
getError	Exception	Si la tâche échoue, cela sera considéré comme une exception.
getBytesTransferred	long	Nombre total d'octets transférés lors de la création de cet instantané.
getTotalByteCount	long	Nombre total d'octets devant être importés.
getUploadSessionUri	String	URI qui peut être utilisé pour poursuivre cette tâche via un autre appel à putFile.
getMetadata	StorageMetadata	Il s'agit des métadonnées envoyées au serveur avant la fin de l'importation. Une fois l'importation terminée, ce sont les métadonnées renvoyées par le serveur.
getTask	UploadTask	Tâche qui a créé cet instantané. Utilisez cette tâche pour annuler, suspendre ou reprendre l'importation.
getStorage	StorageReference	StorageReference utilisé pour créer UploadTask.

Les écouteurs d'événements UploadTask offrent un moyen simple et efficace de surveiller d'importation.

Kotlin+KTX

// Observe state change events such as progress, pause, and resume
// You'll need to import com.google.firebase.storage.component1 and
// com.google.firebase.storage.component2
uploadTask.addOnProgressListener { (bytesTransferred, totalByteCount) ->
    val progress = (100.0 * bytesTransferred) / totalByteCount
    Log.d(TAG, "Upload is $progress% done")
}.addOnPausedListener {
    Log.d(TAG, "Upload is paused")
}
StorageActivity.kt

Java

// Observe state change events such as progress, pause, and resume
uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
        double progress = (100.0 * taskSnapshot.getBytesTransferred()) / taskSnapshot.getTotalByteCount();
        Log.d(TAG, "Upload is " + progress + "% done");
    }
}).addOnPausedListener(new OnPausedListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onPaused(UploadTask.TaskSnapshot taskSnapshot) {
        Log.d(TAG, "Upload is paused");
    }
});
StorageActivity.java

Gérer les modifications du cycle de vie d'une activité

Les importations continuent en arrière-plan, même après une modification du cycle de vie de l'activité (par exemple, en affichant une boîte de dialogue ou en faisant pivoter l'écran). Tous les écouteurs associés restent également associés. Cela pourrait entraîner des résultats inattendus s'ils reçoivent appelé après l'arrêt de l'activité.

Vous pouvez résoudre ce problème en abonneant vos écouteurs avec un champ d'application d'activité pour annuler automatiquement leur enregistrement lorsque l'activité cesse. Ensuite, utilisez la méthode getActiveUploadTasks lorsque l'activité redémarre pour obtenir les tâches d'importation en cours d'exécution ou récemment terminées.

L'exemple ci-dessous illustre cela et montre également comment conserver le chemin de référence de stockage utilisé.

Kotlin+KTX

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)

    // If there's an upload in progress, save the reference so you can query it later
    outState.putString("reference", storageRef.toString())
}

override fun onRestoreInstanceState(savedInstanceState: Bundle) {
    super.onRestoreInstanceState(savedInstanceState)

    // If there was an upload in progress, get its reference and create a new StorageReference
    val stringRef = savedInstanceState.getString("reference") ?: return

    storageRef = Firebase.storage.getReferenceFromUrl(stringRef)

    // Find all UploadTasks under this StorageReference (in this example, there should be one)

    val tasks = storageRef.activeUploadTasks

    if (tasks.size > 0) {
        // Get the task monitoring the upload
        val task = tasks[0]

        // Add new listeners to the task using an Activity scope
        task.addOnSuccessListener(this) {
            // Success!
            // ...
        }
    }
}
UploadActivity.kt

Java

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);

    // If there's an upload in progress, save the reference so you can query it later
    if (mStorageRef != null) {
        outState.putString("reference", mStorageRef.toString());
    }
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);

    // If there was an upload in progress, get its reference and create a new StorageReference
    final String stringRef = savedInstanceState.getString("reference");
    if (stringRef == null) {
        return;
    }
    mStorageRef = FirebaseStorage.getInstance().getReferenceFromUrl(stringRef);

    // Find all UploadTasks under this StorageReference (in this example, there should be one)
    List<UploadTask> tasks = mStorageRef.getActiveUploadTasks();
    if (tasks.size() > 0) {
        // Get the task monitoring the upload
        UploadTask task = tasks.get(0);

        // Add new listeners to the task using an Activity scope
        task.addOnSuccessListener(this, new OnSuccessListener<UploadTask.TaskSnapshot>() {
            @Override
            public void onSuccess(UploadTask.TaskSnapshot state) {
                // Success!
                // ...
            }
        });
    }
}
UploadActivity.java

getActiveUploadTasks récupère toutes les tâches d'importation actives à et en dessous de la une référence fournie. Vous devrez donc peut-être gérer plusieurs tâches.

Poursuite des importations lors des redémarrages de processus

Si votre processus est arrêté, toutes les importations en cours seront interrompues. Cependant, vous pouvez poursuivre l'importation une fois que le processus a redémarré en relançant le une session d'importation avec le serveur. Cela permet d'économiser du temps et de la bande passante en commençant l'importation à partir du début du fichier.

Pour ce faire, commencez l'importation via putFile. Sur le StorageTask obtenu, Appelez getUploadSessionUri et enregistrez la valeur obtenue dans un espace de stockage persistant. (par exemple, SharedPreferences).

Kotlin+KTX

uploadTask = storageRef.putFile(localFile)
uploadTask.addOnProgressListener { taskSnapshot ->
    sessionUri = taskSnapshot.uploadSessionUri
    if (sessionUri != null && !saved) {
        saved = true
        // A persisted session has begun with the server.
        // Save this to persistent storage in case the process dies.
    }
}
UploadActivity.kt

Java

uploadTask = mStorageRef.putFile(localFile);
uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
        Uri sessionUri = taskSnapshot.getUploadSessionUri();
        if (sessionUri != null && !mSaved) {
            mSaved = true;
            // A persisted session has begun with the server.
            // Save this to persistent storage in case the process dies.
        }
    }
});
UploadActivity.java

Après le redémarrage du processus avec une importation interrompue, appelez de nouveau putFile. Toutefois, transmet cette fois l'URI enregistré.

Kotlin+KTX

// resume the upload task from where it left off when the process died.
// to do this, pass the sessionUri as the last parameter
uploadTask = storageRef.putFile(
    localFile,
    storageMetadata { },
    sessionUri,
)
UploadActivity.kt

Java

//resume the upload task from where it left off when the process died.
//to do this, pass the sessionUri as the last parameter
uploadTask = mStorageRef.putFile(localFile,
        new StorageMetadata.Builder().build(), sessionUri);
UploadActivity.java

Les séances durent une semaine. Si vous essayez de reprendre une session après a expiré ou, s'il a rencontré une erreur, vous recevrez un rappel d'échec. Il est de votre responsabilité de vous assurer que le fichier n'a pas changé entre les importations.

Traitement des erreurs

Des erreurs peuvent se produire lors de l'importation pour plusieurs raisons : le fichier local n'existe pas ou l'utilisateur n'a pas l'autorisation d'importer le fichier souhaité. Pour en savoir plus sur les erreurs, consultez la Gérer les erreurs de la documentation.

Exemple complet

Vous trouverez ci-dessous un exemple complet d'importation avec surveillance de la progression et gestion des erreurs :

Kotlin+KTX

// File or Blob
file = Uri.fromFile(File("path/to/mountains.jpg"))

// Create the file metadata
metadata = storageMetadata {
    contentType = "image/jpeg"
}

// Upload file and metadata to the path 'images/mountains.jpg'
uploadTask = storageRef.child("images/${file.lastPathSegment}").putFile(file, metadata)

// Listen for state changes, errors, and completion of the upload.
// You'll need to import com.google.firebase.storage.component1 and
// com.google.firebase.storage.component2
uploadTask.addOnProgressListener { (bytesTransferred, totalByteCount) ->
    val progress = (100.0 * bytesTransferred) / totalByteCount
    Log.d(TAG, "Upload is $progress% done")
}.addOnPausedListener {
    Log.d(TAG, "Upload is paused")
}.addOnFailureListener {
    // Handle unsuccessful uploads
}.addOnSuccessListener {
    // Handle successful uploads on complete
    // ...
}
StorageActivity.kt

Java

// File or Blob
file = Uri.fromFile(new File("path/to/mountains.jpg"));

// Create the file metadata
metadata = new StorageMetadata.Builder()
        .setContentType("image/jpeg")
        .build();

// Upload file and metadata to the path 'images/mountains.jpg'
uploadTask = storageRef.child("images/"+file.getLastPathSegment()).putFile(file, metadata);

// Listen for state changes, errors, and completion of the upload.
uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
        double progress = (100.0 * taskSnapshot.getBytesTransferred()) / taskSnapshot.getTotalByteCount();
        Log.d(TAG, "Upload is " + progress + "% done");
    }
}).addOnPausedListener(new OnPausedListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onPaused(UploadTask.TaskSnapshot taskSnapshot) {
        Log.d(TAG, "Upload is paused");
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle unsuccessful uploads
    }
}).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
    @Override
    public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
        // Handle successful uploads on complete
        // ...
    }
});
StorageActivity.java

Maintenant que vous avez importé des fichiers, voyons comment les télécharger de Cloud Storage.