Importer des fichiers avec Cloud Storage pour C++

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 modifier Firebase Security Rules pour Cloud Storage pour autoriser un 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 à restreindre à nouveau 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 certaines types de fichiers exécutables pour Windows (fichiers avec .exe, extensions .dll et .bat), Android (.apk extension) et Apple (.ipa extension) par Cloud Storage for Firebase et Firebase Hosting. Cette règle permet contre les abus sur notre plate-forme. Les projets de la formule Blaze ne sont pas affectés. Pour en savoir plus, consultez cette FAQ.

Créer une référence

Pour importer un fichier, commencez par créer une référence Cloud Storage à l'emplacement dans Cloud Storage où vous souhaitez importer le fichier.

Vous pouvez créer une référence en ajoutant des chemins d'accès enfants à la racine de votre Bucket Cloud Storage:

// Create a root reference
StorageReference storage_ref = storage->GetReference();

// Create a reference to "mountains.jpg"
StorageReference mountains_ref = storage_ref.Child("mountains.jpg");

// Create a reference to 'images/mountains.jpg'
StorageReference mountain_images_ref = storage_ref.Child("images/mountains.jpg");

// While the file names are the same, the references point to different files
mountains_ref.name() == mountain_images_ref.name();           // true
mountains_ref.full_path() == mountain_images_ref.full_path(); // false

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

Importer des fichiers

Une fois que vous disposez d'une référence, vous pouvez importer des fichiers dans Cloud Storage de deux manières :

1. Importer à partir d'un tampon d'octets en mémoire
2. Importer à partir d'un chemin d'accès représentant un fichier sur l'appareil

Importer à partir de données en mémoire

La méthode PutData() est le moyen le plus simple d'importer un fichier dans Cloud Storage PutData() prend un tampon d'octets et renvoie une Future<Metadata>, qui contiendra des informations sur le fichier lorsque l'avenir se termine. Vous pouvez utiliser un Controller pour gérer l'importation et et surveiller son état.

// Data in memory
const size_t kByteBufferSize = ...
uint8_t byte_buffer[kByteBufferSize] = { ... };

// Create a reference to the file you want to upload
StorageReference rivers_ref = storage_ref.Child("images/rivers.jpg");

// Upload the file to the path "images/rivers.jpg"
Future future = rivers_ref.PutBytes(byte_buffer, kByteBufferSize);

Au moment où la demande a été faite, nous devons attendre que l'avenir avant l'importation du fichier. Étant donné que les jeux s'exécutent généralement en boucle, et reposent moins sur le rappel que d'autres applications, vous sondez généralement l'achèvement.

if (future.status() != firebase::kFutureStatusPending) {
  if (future.status() != firebase::kFutureStatusComplete) {
    LogMessage("ERROR: GetData() returned an invalid future.");
    // Handle the error...
  } else if (future.Error() != firebase::storage::kErrorNone) {
    LogMessage("ERROR: GetData() returned error %d: %s", future.Error(),
               future.error_message());
    // Handle the error...
    }
  } else {
    // Metadata contains file metadata such as size, content-type, and download URL.
    Metadata* metadata = future.Result();
    std::string download_url = metadata->download_url();
  }
}

Importer à partir d'un fichier local

Vous pouvez importer des fichiers locaux sur les appareils, tels que des photos et des vidéos à partir du appareil photo, avec la méthode PutFile(). PutFile() prend un std::string représentant le chemin d'accès au fichier et renvoie une Future<Metadata>, qui contiendra des informations sur le fichier lorsque l'objet Future se termine. Vous pouvez utiliser un Controller pour gérer votre importation et surveiller son état.

// File located on disk
std::string local_file = ...

// Create a reference to the file you want to upload
StorageReference rivers_ref = storage_ref.Child("images/rivers.jpg");

// Upload the file to the path "images/rivers.jpg"
Future future = rivers_ref.PutFile(localFile);

// Wait for Future to complete...

if (future.Error() != firebase::storage::kErrorNone) {
  // Uh-oh, an error occurred!
} else {
  // Metadata contains file metadata such as size, content-type, and download URL.
  Metadata* metadata = future.Result();
  std::string download_url = metadata->download_url();
}

Si vous souhaitez gérer activement votre importation, vous pouvez fournir un Controller au paramètre PutFile() ou PutBytes(). Vous pouvez ainsi utiliser le contrôleur pour observer l'opération d'importation en cours. Consultez l'article Gérer les importations pour en savoir plus. plus d'informations.

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 Propriétés de métadonnées de fichier classiques telles que name, size et content_type (communément appelé type MIME). La méthode PutFile() infère automatiquement le type de contenu à partir de l'extension de nom de fichier, mais vous pouvez remplacer le type détecté automatiquement en spécifiant content_type dans les métadonnées. Si vous ne fournir un content_type, et Cloud Storage ne peut pas déduire une valeur par défaut à partir de l'extension de fichier, Cloud Storage utilise application/octet-stream. Voir la boîte de dialogue Utiliser les métadonnées du fichier pour en savoir plus sur les métadonnées de fichiers.

// Create storage reference
StorageReference mountains_ref = storage_ref.Child("images/mountains.jpg");

// Create file metadata including the content type
StorageMetadata metadata;
metadata.set_content_type("image/jpeg");

// Upload data and metadata
mountains_ref.PutBytes(data, metadata);

// Upload file and metadata
mountains_ref.PutFile(local_file, metadata);

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() sur Controller, que vous pouvez transmettre éventuellement aux méthodes PutBytes() ou PutFile().

// Start uploading a file
firebase::storage::Controller controller;
storage_ref.Child("images/mountains.jpg").PutFile(local_file, nullptr, &controller);

// Pause the upload
controller.Pause();

// Resume the upload
controller.Resume();

// Cancel the upload
controller.Cancel();

Surveiller la progression de l'importation

Vous pouvez associer des écouteurs aux importations afin de surveiller leur progression.

class MyListener : public firebase::storage::Listener {
 public:
  virtual void OnProgress(firebase::storage::Controller* controller) {
    // A progress event occurred
  }
};

{
  // Start uploading a file
  MyEventListener my_listener;
  storage_ref.Child("images/mountains.jpg").PutFile(local_file, my_listener);
}

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.

Étapes suivantes

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