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 vous pouvez créer une référence à partir d'une URL gs:// ou https:// existante faisant référence à 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 avez une référence, vous pouvez télécharger des fichiers depuis Cloud Storage de quatre manières :

  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épendra 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 chargera 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, assurez-vous de définir une taille maximale 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 à mesure qu'elles sont chargées. 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 qui vous permet d'effectuer des opérations ou des calculs à forte latence, comme le stockage du contenu sur le 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, ce qui vous permet d'annuler l'opération ou d'être informé de sa progression.

Télécharger dans un fichier local

La méthode GetFileAsync() télécharge un fichier directement sur un appareil local. Utilisez cette option 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 ticks 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 les erreurs de téléchargement, par exemple si le fichier n'existe pas ou si l'utilisateur n'est pas autorisé à y accéder. 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 les métadonnées des fichiers stockés dans Cloud Storage.