Télécharger des fichiers avec Cloud Storage pour Unity

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.

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.

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

// Create a reference 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");

Télécharger les fichiers

Une fois que vous disposez d'une référence, vous pouvez télécharger des fichiers depuis Cloud Storage de quatre manières différentes:

1. Télécharger à partir d'une URL
2. Télécharger dans un tableau d'octets
3. Télécharger avec un flux
4. Télécharger dans un fichier local

La méthode que vous utiliserez pour récupérer vos fichiers dépend de la façon dont vous souhaitez consommer les données dans votre jeu.

Télécharger à partir d'une URL

Si vous souhaitez utiliser une URL avec WWW ou UnityWebRequest d'Unity, vous pouvez obtenir une URL de téléchargement pour un fichier en appelant GetDownloadUrlAsync().

// Fetch the download URL
reference.GetDownloadUrlAsync().ContinueWithOnMainThread(task => {
    if (!task.IsFaulted && !task.IsCanceled) {
        Debug.Log("Download URL: " + task.Result);
        // ... now download the file via WWW or UnityWebRequest.
    }
});

Télécharger dans un tableau d'octets

Vous pouvez télécharger le fichier dans un tampon d'octets en mémoire à l'aide de la méthode GetBytesAsync(). Cette méthode charge 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 vous protéger contre les problèmes de mémoire, veillez à définir la taille maximale sur une valeur que votre application peut gérer, ou utilisez une autre méthode de téléchargement.

// Download in memory with a maximum allowed size of 1MB (1 * 1024 * 1024 bytes)
const long maxAllowedSize = 1 * 1024 * 1024;
reference.GetBytesAsync(maxAllowedSize).ContinueWithOnMainThread(task => {
    if (task.IsFaulted || task.IsCanceled) {
        Debug.LogException(task.Exception);
        // Uh-oh, an error occurred!
    }
    else {
        byte[] fileContents = task.Result;
        Debug.Log("Finished downloading!");
    }
});

Télécharger via un flux

Le téléchargement du fichier avec un flux vous permet de traiter les données au fur et à mesure de leur chargement. Vous bénéficiez ainsi d'une flexibilité maximale pour gérer votre téléchargement. Appelez GetStreamAsync() et transmettez votre propre processeur de flux comme premier argument. Ce délégué sera appelé sur un thread d'arrière-plan avec un flux, ce qui vous permet d'effectuer des opérations ou des calculs à forte latence, tels que le stockage du contenu sur disque.

// Download via a Stream
reference.GetStreamAsync(stream => {
    // Do something with the stream here.
    //
    // This code runs on a background thread which reduces the impact
    // to your framerate.
    //
    // If you want to do something on the main thread, you can do that in the
    // progress eventhandler (second argument) or ContinueWith to execute it
    // at task completion.
}, null, CancellationToken.None);

GetStreamAsync() accepte des arguments facultatifs après le processeur de flux qui vous permettent d'annuler l'opération ou d'être informé de la progression.

Télécharger dans un fichier local

La méthode GetFileAsync() télécharge un fichier directement sur un appareil local. Utilisez-la si vos utilisateurs souhaitent accéder au fichier hors connexion ou le partager dans une autre application.

// Create local filesystem URL
string localUrl = "file:///local/images/island.jpg";

// Download to the local filesystem
reference.GetFileAsync(localUrl).ContinueWithOnMainThread(task => {
    if (!task.IsFaulted && !task.IsCanceled) {
        Debug.Log("File downloaded.");
    }
});

Vous pouvez associer des écouteurs aux téléchargements afin de surveiller leur progression. L'écouteur suit l'interface System.IProgress<T> standard. Vous pouvez utiliser une instance de la classe StorageProgress pour fournir votre propre Action<T> en tant que rappel pour les "tic" de progression.

// Create local filesystem URL
string localUrl = "file:///local/images/island.jpg";

// Start downloading a file
Task task = reference.GetFileAsync(localFile,
    new StorageProgress<DownloadState>(state => {
        // called periodically during the download
        Debug.Log(String.Format(
            "Progress: {0} of {1} bytes transferred.",
            state.BytesTransferred,
            state.TotalByteCount
        ));
    }), CancellationToken.None);

task.ContinueWithOnMainThread(resultTask => {
    if (!resultTask.IsFaulted && !resultTask.IsCanceled) {
        Debug.Log("Download finished.");
    }
});

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.

Étapes suivantes

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