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

Cloud Storage pour 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, créez d'abord 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 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");

Telecharger des 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 sur 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 manière dont vous souhaitez consommer les données de votre jeu.

Télécharger à partir d'une URL

Si vous souhaitez utiliser une URL avec WWW ou UnityWebRequest de 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 sur 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 tout le contenu de votre fichier en mémoire. Si vous demandez un fichier plus volumineux que la mémoire disponible de votre application, votre application plantera. Pour vous protéger contre les problèmes de mémoire, assurez-vous de définir la taille maximale sur quelque chose que vous savez 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 Stream vous permet de traiter les données au fur et à mesure de leur chargement. Cela vous donne une flexibilité maximale lors du traitement de 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 Stream qui vous permet d'effectuer des opérations ou des calculs gourmands en latence tels que 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() prend un argument facultatif après le processeur de flux qui vous permet 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 périphérique local. Utilisez-le si vos utilisateurs souhaitent accéder au fichier hors ligne ou partager le fichier 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 auditeurs aux téléchargements afin de suivre la progression du téléchargement. L'écouteur suit l'interface standard System.IProgress<T> . Vous pouvez utiliser une instance de la classe StorageProgress pour fournir votre propre Action<T> comme 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

Il existe un certain nombre de raisons pour lesquelles des erreurs peuvent survenir lors du téléchargement, notamment le fait que le fichier n'existe pas ou que l'utilisateur n'est pas autorisé à accéder au fichier souhaité. Plus d’informations sur les erreurs peuvent être trouvées dans la section Gérer les erreurs de la documentation.

Prochaines étapes

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