Create a Storage Reference with Cloud Storage for Unity

Your files are stored in a Google Cloud
Storage bucket. The files in this bucket are
presented in a hierarchical structure, just like the file system on your local
hard disk, or the data in the Firebase Realtime Database. By creating a reference
to a file, your app gains access to it. These references can then be used to
upload or download data, get or update metadata or delete the file. A reference
can either point to a specific file or to a higher level node in the hierarchy.

If you've used the Firebase Realtime Database, these paths
should seem very familiar to you. However, your file data is stored in Google
Cloud Storage, not in the Realtime Database.

Create a Reference

Create a reference to upload, download, or delete a file,
or to get or update its metadata. A reference
can be thought of as a pointer to a file in the cloud. References are
lightweight, so you can create as many as you need. They are also reusable for
multiple operations.

References are created from the Firebase.Storage.FirebaseStorage service on
your Firebase app by calling the GetReferenceFromUrl() method and passing in a
URL of the form gs://<your-cloud-storage-bucket>. You can find this URL in
the Storage section of the Firebase console.

// Get a reference to the storage service, using the default Firebase App
Firebase.Storage.FirebaseStorage storage = Firebase.Storage.FirebaseStorage.DefaultInstance;
// Create a storage reference from our storage service
Firebase.Storage.StorageReference storage_ref =
storage.GetReferenceFromUrl("gs://<your-cloud-storage-bucket>");

You can create a reference to a location lower in the tree, for example
'images/space.jpg', by using the child method on an existing reference.

Navigate with References

You can also use the Parent and Root methods to navigate up in our file
hierarchy. Parent navigates up one level, while Root navigates all the way
to the top.

// Parent allows us to move to the parent of a reference
// images_ref now points to 'images'
Firebase.Storage.StorageReference images_ref = space_ref.Parent;
// Root allows us to move all the way back to the top of our bucket
// root_ref now points to the root
Firebase.Storage.StorageReference root_ref = space_ref.Root;

Child, Parent, and Root can be chained together multiple times, as
each returns a reference. The exception is the Parent of Root, which
is an invalid StorageReference.

// References can be chained together multiple times
// earth_ref points to "images/earth.jpg"
Firebase.Storage.StorageReference earth_ref =
space_ref.Parent.Child("earth.jpg");
// null_ref is null since the parent of root is an invalid StorageReference
Firebase.Storage.StorageReference null_ref = space_ref.Root.Parent;

Reference Methods

You can inspect references to better understand the files they point to using
the Path, Name, and Bucket properties. These properties get the file's
full path, name, and bucket.

// Reference's path is: "images/space.jpg"
// This is analogous to a file path on disk
space_ref.Path;
// Reference's name is the last segment of the full path: "space.jpg"
// This is analogous to the file name
space_ref.Name;
// Reference's bucket is the name of the storage bucket where files are stored
space_ref.Bucket;

Limitations on References

Reference paths and names can contain any sequence of valid Unicode characters,
but certain restrictions are imposed including:

Total length of reference.Path must be between 1 and 1024 bytes when UTF-8
encoded.