Télécharger des fichiers avec Cloud Storage sur Android

Cloud Storage for Firebase vous permet de télécharger rapidement et facilement des fichiers à partir d'un bucket Cloud Storage fourni et géré par Firebase.

Remarque :Par défaut, un bucket Cloud Storage for Firebase nécessite Firebase Authentication pour effectuer toute 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é dans des situations spécifiques. Toutefois, dans la plupart des cas, nous vous recommandons vivement de restreindre l'accès et de configurer des règles de sécurité strictes (en particulier pour les applications de production). Notez que si vous utilisez Google App Engine et que vous disposez d'un bucket Cloud Storage par défaut avec un format de nom *.appspot.com, vous devrez peut-être examiner l'impact de vos règles de sécurité sur l'accès aux fichiers App Engine.

Créer une référence

Pour télécharger un fichier, commencez par créer une référence Cloud Storage au fichier que vous souhaitez télécharger.

Vous pouvez créer une référence en ajoutant des chemins d'accès enfants à la racine de votre bucket Cloud Storage, ou à partir d'une URL gs:// ou https:// existante référençant un objet dans Cloud Storage.

Kotlin

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

// Create a reference with an initial file path and name
val pathReference = storageRef.child("images/stars.jpg")

// Create a reference to a file from a Google Cloud Storage URI
val gsReference = storage.getReferenceFromUrl("gs://bucket/images/stars.jpg")

// Create a reference from an HTTPS URL
// Note that in the URL, characters are URL escaped!
val httpsReference = storage.getReferenceFromUrl(
    "https://firebasestorage.googleapis.com/b/bucket/o/images%20stars.jpg",
)
StorageActivity.kt

Java

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

// Create a reference with an initial file path and name
StorageReference pathReference = storageRef.child("images/stars.jpg");

// Create a reference to a file from a Google Cloud Storage URI
StorageReference gsReference = storage.getReferenceFromUrl("gs://bucket/images/stars.jpg");

// Create a reference from an HTTPS URL
// Note that in the URL, characters are URL escaped!
StorageReference httpsReference = storage.getReferenceFromUrl("https://firebasestorage.googleapis.com/b/bucket/o/images%20stars.jpg");
StorageActivity.java

Télécharger les fichiers

Une fois que vous disposez d'une référence, vous pouvez télécharger des fichiers à partir de Cloud Storage en appelant getBytes() ou getStream(). Si vous préférez télécharger le fichier avec une autre bibliothèque, vous pouvez obtenir une URL de téléchargement avec getDownloadUrl().

Télécharger en mémoire

Téléchargez le fichier dans un byte[] à l'aide de la méthode getBytes(). Il s'agit du moyen le plus simple de télécharger un fichier, mais il doit charger l'intégralité du contenu de votre fichier en mémoire. Si vous demandez un fichier plus volumineux que la mémoire disponible de votre application, celle-ci plantera. Pour éviter les problèmes de mémoire, getBytes() prend un nombre maximal d'octets à télécharger. Définissez la taille maximale sur une valeur que votre application peut gérer, ou utilisez une autre méthode de téléchargement.

Kotlin

var islandRef = storageRef.child("images/island.jpg")

val ONE_MEGABYTE: Long = 1024 * 1024
islandRef.getBytes(ONE_MEGABYTE).addOnSuccessListener {
    // Data for "images/island.jpg" is returned, use this as needed
}.addOnFailureListener {
    // Handle any errors
}
StorageActivity.kt

Java

StorageReference islandRef = storageRef.child("images/island.jpg");

final long ONE_MEGABYTE = 1024 * 1024;
islandRef.getBytes(ONE_MEGABYTE).addOnSuccessListener(new OnSuccessListener<byte[]>() {
    @Override
    public void onSuccess(byte[] bytes) {
        // Data for "images/island.jpg" is returns, use this as needed
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle any errors
    }
});
StorageActivity.java

Télécharger dans un fichier local

La méthode getFile() télécharge un fichier directement sur un appareil local. Utilisez cette méthode si vos utilisateurs souhaitent accéder au fichier hors connexion ou le partager dans une autre application. getFile() renvoie un DownloadTask que vous pouvez utiliser pour gérer votre téléchargement et surveiller son état.

Kotlin

islandRef = storageRef.child("images/island.jpg")

val localFile = File.createTempFile("images", "jpg")

islandRef.getFile(localFile).addOnSuccessListener {
    // Local temp file has been created
}.addOnFailureListener {
    // Handle any errors
}
StorageActivity.kt

Java

islandRef = storageRef.child("images/island.jpg");

File localFile = File.createTempFile("images", "jpg");

islandRef.getFile(localFile).addOnSuccessListener(new OnSuccessListener<FileDownloadTask.TaskSnapshot>() {
    @Override
    public void onSuccess(FileDownloadTask.TaskSnapshot taskSnapshot) {
        // Local temp file has been created
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle any errors
    }
});
StorageActivity.java

Pour gérer activement votre téléchargement, consultez la section Gérer les téléchargements.

Télécharger des données via une URL

Si vous disposez déjà d'une infrastructure de téléchargement basée sur des URL ou si vous souhaitez simplement partager une URL, vous pouvez obtenir l'URL de téléchargement d'un fichier en appelant la méthode getDownloadUrl() sur une référence Cloud Storage.

Kotlin

storageRef.child("users/me/profile.png").downloadUrl.addOnSuccessListener {
    // Got the download URL for 'users/me/profile.png'
}.addOnFailureListener {
    // Handle any errors
}
StorageActivity.kt

Java

storageRef.child("users/me/profile.png").getDownloadUrl().addOnSuccessListener(new OnSuccessListener<Uri>() {
    @Override
    public void onSuccess(Uri uri) {
        // Got the download URL for 'users/me/profile.png'
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle any errors
    }
});
StorageActivity.java

Télécharger des images avec FirebaseUI

FirebaseUI fournit des liaisons mobiles natives simples, personnalisables et prêtes à la production pour éliminer le code standard et promouvoir les bonnes pratiques de Google. Avec FirebaseUI, vous pouvez télécharger, mettre en cache et afficher rapidement et facilement des images depuis Cloud Storage grâce à notre intégration avec Glide.

Tout d'abord, ajoutez FirebaseUI à votre app/build.gradle:

dependencies {
    // FirebaseUI Storage only
    implementation 'com.firebaseui:firebase-ui-storage:7.2.0'
}

Vous pouvez ensuite charger des images directement depuis Cloud Storage dans un ImageView:

Kotlin

// Reference to an image file in Cloud Storage
val storageReference = Firebase.storage.reference

// ImageView in your Activity
val imageView = findViewById<ImageView>(R.id.imageView)

// Download directly from StorageReference using Glide
// (See MyAppGlideModule for Loader registration)
Glide.with(context)
    .load(storageReference)
    .into(imageView)
FirebaseUIActivity.kt

Java

// Reference to an image file in Cloud Storage
StorageReference storageReference = FirebaseStorage.getInstance().getReference();

// ImageView in your Activity
ImageView imageView = findViewById(R.id.imageView);

// Download directly from StorageReference using Glide
// (See MyAppGlideModule for Loader registration)
Glide.with(context)
        .load(storageReference)
        .into(imageView);
FirebaseUIActivity.java

Gérer les modifications du cycle de vie des activités

Les téléchargements 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 que vous aviez associés resteront également associés. Cela peut entraîner des résultats inattendus s'ils sont appelés après l'arrêt de l'activité.

Pour résoudre ce problème, abonnez vos écouteurs avec un champ d'application d'activité afin de les désenregistrer automatiquement lorsque l'activité s'arrête. Ensuite, utilisez la méthode getActiveDownloadTasks lorsque l'activité redémarre pour obtenir les tâches de téléchargement qui sont toujours en cours d'exécution ou qui ont été 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

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

    // If there's a download 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 a download in progress, get its reference and create a new StorageReference
    val stringRef = savedInstanceState.getString("reference") ?: return

    storageRef = Firebase.storage.getReferenceFromUrl(stringRef)

    // Find all DownloadTasks under this StorageReference (in this example, there should be one)
    val tasks = storageRef.activeDownloadTasks

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

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

Java

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

    // If there's a download 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 a download 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 DownloadTasks under this StorageReference (in this example, there should be one)
    List<FileDownloadTask> tasks = mStorageRef.getActiveDownloadTasks();
    if (tasks.size() > 0) {
        // Get the task monitoring the download
        FileDownloadTask task = tasks.get(0);

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

Gérer les erreurs

Plusieurs raisons peuvent expliquer l'apparition d'erreurs lors du téléchargement, y compris l'absence de fichier ou l'absence d'autorisation de l'utilisateur pour accéder au fichier souhaité. Pour en savoir plus sur les erreurs, consultez la section Gérer les erreurs de la documentation.

Exemple complet

Vous trouverez ci-dessous un exemple complet de téléchargement avec gestion des erreurs:

Kotlin

storageRef.child("users/me/profile.png").getBytes(Long.MAX_VALUE).addOnSuccessListener {
    // Use the bytes to display the image
}.addOnFailureListener {
    // Handle any errors
}
StorageActivity.kt

Java

storageRef.child("users/me/profile.png").getBytes(Long.MAX_VALUE).addOnSuccessListener(new OnSuccessListener<byte[]>() {
    @Override
    public void onSuccess(byte[] bytes) {
        // Use the bytes to display the image
    }
}).addOnFailureListener(new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception exception) {
        // Handle any errors
    }
});
StorageActivity.java

Vous pouvez également obtenir et mettre à jour des métadonnées pour les fichiers stockés dans Cloud Storage.