Mit Cloud Storage for Firebase können Sie schnell und einfach Dateien in einen von Firebase bereitgestellten und verwalteten Bucket Cloud Storage hochladen.
Dateien hochladen
Zum Hochladen einer Datei auf Cloud Storage erstellen Sie zuerst einen Verweis auf die den vollständigen Pfad der Datei, einschließlich des Dateinamens.
Kotlin+KTX
// Create a storage reference from our app val storageRef = storage.reference // Create a reference to "mountains.jpg" val mountainsRef = storageRef.child("mountains.jpg") // Create a reference to 'images/mountains.jpg' val mountainImagesRef = storageRef.child("images/mountains.jpg") // While the file names are the same, the references point to different files mountainsRef.name == mountainImagesRef.name // true mountainsRef.path == mountainImagesRef.path // false
Java
// Create a storage reference from our app StorageReference storageRef = storage.getReference(); // Create a reference to "mountains.jpg" StorageReference mountainsRef = storageRef.child("mountains.jpg"); // Create a reference to 'images/mountains.jpg' StorageReference mountainImagesRef = storageRef.child("images/mountains.jpg"); // While the file names are the same, the references point to different files mountainsRef.getName().equals(mountainImagesRef.getName()); // true mountainsRef.getPath().equals(mountainImagesRef.getPath()); // false
Nachdem du eine entsprechende Referenz erstellt hast, rufst du die putBytes()
auf.
putFile()
- oder putStream()
-Methode zum Hochladen der Datei
an Cloud Storage.
Sie können keine Daten mit einem Verweis auf das Stammverzeichnis Ihres Cloud Storage Bucket. Die Referenz muss auf eine untergeordnete URL verweisen.
Aus Daten im Arbeitsspeicher hochladen
Die Methode putBytes()
ist die einfachste Möglichkeit, ein
in Cloud Storage verschieben. putBytes()
gibt einen byte[]
-Fehler zurück und
UploadTask
, mit dem du den Status des Uploads verwalten und beobachten kannst.
Kotlin+KTX
// Get the data from an ImageView as bytes imageView.isDrawingCacheEnabled = true imageView.buildDrawingCache() val bitmap = (imageView.drawable as BitmapDrawable).bitmap val baos = ByteArrayOutputStream() bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos) val data = baos.toByteArray() var uploadTask = mountainsRef.putBytes(data) uploadTask.addOnFailureListener { // Handle unsuccessful uploads }.addOnSuccessListener { taskSnapshot -> // taskSnapshot.metadata contains file metadata such as size, content-type, etc. // ... }
Java
// Get the data from an ImageView as bytes imageView.setDrawingCacheEnabled(true); imageView.buildDrawingCache(); Bitmap bitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); byte[] data = baos.toByteArray(); UploadTask uploadTask = mountainsRef.putBytes(data); uploadTask.addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception exception) { // Handle unsuccessful uploads } }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() { @Override public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) { // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc. // ... } });
Da putBytes()
eine byte[]
akzeptiert, muss Ihre App den gesamten Inhalt einer Datei gleichzeitig im Arbeitsspeicher halten. Verwenden Sie gegebenenfalls putStream()
oder
putFile()
, um weniger Arbeitsspeicher zu verbrauchen.
Aus einem Stream hochladen
Die putStream()
-Methode ist die vielseitigste Möglichkeit, eine Datei in Cloud Storage hochzuladen. putStream()
nimmt eine InputStream
und kehrt zurück
Eine UploadTask
, mit der du den Status des Uploads verwalten und überwachen kannst.
Kotlin+KTX
val stream = FileInputStream(File("path/to/images/rivers.jpg")) uploadTask = mountainsRef.putStream(stream) uploadTask.addOnFailureListener { // Handle unsuccessful uploads }.addOnSuccessListener { taskSnapshot -> // taskSnapshot.metadata contains file metadata such as size, content-type, etc. // ... }
Java
InputStream stream = new FileInputStream(new File("path/to/images/rivers.jpg")); uploadTask = mountainsRef.putStream(stream); uploadTask.addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception exception) { // Handle unsuccessful uploads } }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() { @Override public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) { // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc. // ... } });
Aus einer lokalen Datei hochladen
Mit der Methode putFile()
können Sie lokale Dateien wie Fotos und Videos von der Kamera auf das Gerät hochladen. putFile()
nimmt eine File
entgegen und gibt eine UploadTask
zurück, mit der du den Status des Uploads verwalten und beobachten kannst.
Kotlin+KTX
var file = Uri.fromFile(File("path/to/images/rivers.jpg")) val riversRef = storageRef.child("images/${file.lastPathSegment}") uploadTask = riversRef.putFile(file) // Register observers to listen for when the download is done or if it fails uploadTask.addOnFailureListener { // Handle unsuccessful uploads }.addOnSuccessListener { taskSnapshot -> // taskSnapshot.metadata contains file metadata such as size, content-type, etc. // ... }
Java
Uri file = Uri.fromFile(new File("path/to/images/rivers.jpg")); StorageReference riversRef = storageRef.child("images/"+file.getLastPathSegment()); uploadTask = riversRef.putFile(file); // Register observers to listen for when the download is done or if it fails uploadTask.addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception exception) { // Handle unsuccessful uploads } }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() { @Override public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) { // taskSnapshot.getMetadata() contains file metadata such as size, content-type, etc. // ... } });
Download-URL abrufen
Nach dem Hochladen einer Datei können Sie eine URL zum Herunterladen der Datei erhalten, indem Sie folgenden Befehl aufrufen:
Die Methode getDownloadUrl()
für die StorageReference
:
Kotlin+KTX
val ref = storageRef.child("images/mountains.jpg") uploadTask = ref.putFile(file) val urlTask = uploadTask.continueWithTask { task -> if (!task.isSuccessful) { task.exception?.let { throw it } } ref.downloadUrl }.addOnCompleteListener { task -> if (task.isSuccessful) { val downloadUri = task.result } else { // Handle failures // ... } }
Java
final StorageReference ref = storageRef.child("images/mountains.jpg"); uploadTask = ref.putFile(file); Task<Uri> urlTask = uploadTask.continueWithTask(new Continuation<UploadTask.TaskSnapshot, Task<Uri>>() { @Override public Task<Uri> then(@NonNull Task<UploadTask.TaskSnapshot> task) throws Exception { if (!task.isSuccessful()) { throw task.getException(); } // Continue with the task to get the download URL return ref.getDownloadUrl(); } }).addOnCompleteListener(new OnCompleteListener<Uri>() { @Override public void onComplete(@NonNull Task<Uri> task) { if (task.isSuccessful()) { Uri downloadUri = task.getResult(); } else { // Handle failures // ... } } });
Dateimetadaten hinzufügen
Sie können auch Metadaten beim Hochladen von Dateien angeben.
Diese Metadaten enthalten typische Dateimetadatenattribute wie name
, size
,
und contentType
(allgemein als MIME-Typ bezeichnet). Bei der putFile()
-Methode wird der MIME-Typ automatisch anhand der File
-Erweiterung abgeleitet. Sie können den automatisch erkannten Typ jedoch überschreiben, indem Sie in den Metadaten contentType
angeben. Wenn
Sie kein contentType
angeben und Cloud Storage kann keinen
Standardeinstellung der Dateiendung, Cloud Storage verwendet
application/octet-stream
Weitere Informationen finden Sie im Abschnitt Dateimetadaten verwenden.
finden Sie weitere Informationen zu Dateimetadaten.
Kotlin+KTX
// Create file metadata including the content type var metadata = storageMetadata { contentType = "image/jpg" } // Upload the file and metadata uploadTask = storageRef.child("images/mountains.jpg").putFile(file, metadata)
Java
// Create file metadata including the content type StorageMetadata metadata = new StorageMetadata.Builder() .setContentType("image/jpg") .build(); // Upload the file and metadata uploadTask = storageRef.child("images/mountains.jpg").putFile(file, metadata);
Uploads verwalten
Sie können Uploads nicht nur starten, sondern auch mit den folgenden Tools pausieren, fortsetzen und abbrechen:
die Methoden pause()
, resume()
und cancel()
. Termine pausieren und fortsetzen
Die Statusänderungen von pause
und progress
werden ausgelöst. Stornieren eines
Upload schlägt den Upload fehl und es wird ein Fehler angezeigt, der darauf hinweist, dass der
Upload wurde abgebrochen.
Kotlin+KTX
uploadTask = storageRef.child("images/mountains.jpg").putFile(file) // Pause the upload uploadTask.pause() // Resume the upload uploadTask.resume() // Cancel the upload uploadTask.cancel()
Java
uploadTask = storageRef.child("images/mountains.jpg").putFile(file); // Pause the upload uploadTask.pause(); // Resume the upload uploadTask.resume(); // Cancel the upload uploadTask.cancel();
Upload-Fortschritt überwachen
Sie können Listener hinzufügen, um Erfolg, Fehler, Fortschritt oder Pausen in der Upload-Aufgabe:
Listener-Typ | Typische Nutzung |
---|---|
OnProgressListener |
Dieser Listener wird bei der Übertragung von Daten regelmäßig aufgerufen und kann zum Ausfüllen einer Upload-/Download-Anzeige verwendet werden. |
OnPausedListener |
Dieser Listener wird immer dann aufgerufen, wenn die Aufgabe pausiert wird. |
OnSuccessListener |
Dieser Listener wird aufgerufen, wenn die Aufgabe erfolgreich abgeschlossen wurde. |
OnFailureListener |
Dieser Listener wird jedes Mal aufgerufen, wenn der Upload fehlgeschlagen ist. Das kann auf Netzwerkzeitüberschreitungen, Autorisierungsfehler oder den Abbruch der Aufgabe zurückzuführen sein. |
OnFailureListener
wird mit einer Exception
-Instanz aufgerufen. Andere Listener werden mit einem UploadTask.TaskSnapshot
-Objekt aufgerufen.
Dieses Objekt ist eine unveränderliche Ansicht der Aufgabe zum Zeitpunkt des Ereignisses.
Ein UploadTask.TaskSnapshot
enthält die folgenden Attribute:
Attribut | Typ | Beschreibung |
---|---|---|
getDownloadUrl |
String |
Eine URL, mit der das Objekt heruntergeladen werden kann. Dies ist eine öffentliche URL, die nicht erraten werden kann und die an andere Clients weitergegeben werden kann. Dieser Wert wird erfasst, sobald ein Upload abgeschlossen ist. |
getError |
Exception |
Wenn die Aufgabe fehlgeschlagen ist, wird die Ursache als Ausnahme angegeben. |
getBytesTransferred |
long |
Die Gesamtzahl der Byte, die übertragen wurden, als dieser Snapshot erstellt wurde. |
getTotalByteCount |
long |
Die Gesamtzahl der Byte, die voraussichtlich hochgeladen werden. |
getUploadSessionUri |
String |
Ein URI, mit dem diese Aufgabe über einen weiteren Aufruf von putFile fortgesetzt werden kann. |
getMetadata |
StorageMetadata |
Bevor ein Upload abgeschlossen wird, werden dies an den Server gesendet. Nach Abschluss des Uploads werden diese Metadaten vom Server zurückgegeben. |
getTask |
UploadTask |
Die Aufgabe, die diesen Snapshot erstellt hat. Mit dieser Aufgabe können Sie den Upload abbrechen, pausieren oder fortsetzen. |
getStorage |
StorageReference |
Die StorageReference , mit der die UploadTask erstellt wurde. |
Die UploadTask
-Event-Listener bieten eine einfache und leistungsstarke Möglichkeit,
laden Sie Ereignisse hoch.
Kotlin+KTX
// Observe state change events such as progress, pause, and resume // You'll need to import com.google.firebase.storage.component1 and // com.google.firebase.storage.component2 uploadTask.addOnProgressListener { (bytesTransferred, totalByteCount) -> val progress = (100.0 * bytesTransferred) / totalByteCount Log.d(TAG, "Upload is $progress% done") }.addOnPausedListener { Log.d(TAG, "Upload is paused") }
Java
// Observe state change events such as progress, pause, and resume uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() { @Override public void onProgress(UploadTask.TaskSnapshot taskSnapshot) { double progress = (100.0 * taskSnapshot.getBytesTransferred()) / taskSnapshot.getTotalByteCount(); Log.d(TAG, "Upload is " + progress + "% done"); } }).addOnPausedListener(new OnPausedListener<UploadTask.TaskSnapshot>() { @Override public void onPaused(UploadTask.TaskSnapshot taskSnapshot) { Log.d(TAG, "Upload is paused"); } });
Änderungen am Aktivitätslebenszyklus verarbeiten
Uploads werden im Hintergrund fortgesetzt, auch wenn sich der Aktivitätslebenszyklus ändert (z. B. z. B. wenn Sie ein Dialogfeld präsentieren oder den Bildschirm drehen. Alle von Ihnen angehängten Hörer bleiben ebenfalls verbunden. Dies kann zu unerwarteten Ergebnissen führen, wenn nach dem Beenden der Aktivität aufgerufen.
Sie können dieses Problem beheben, indem Sie Ihre Listener mit einem Aktivitätsbereich abonnieren, damit sie automatisch abgemeldet werden, wenn die Aktivität beendet wird. Verwenden Sie dann die Methode
getActiveUploadTasks
-Methode, wenn die Aktivität neu gestartet wird, um Uploadaufgaben abzurufen
die noch ausgeführt werden
oder kürzlich abgeschlossen wurden.
Das folgende Beispiel verdeutlicht dies und zeigt auch, wie der Speicher beibehalten wird. Referenzpfad verwendet.
Kotlin+KTX
override fun onSaveInstanceState(outState: Bundle) { super.onSaveInstanceState(outState) // If there's an upload in progress, save the reference so you can query it later outState.putString("reference", storageRef.toString()) } override fun onRestoreInstanceState(savedInstanceState: Bundle) { super.onRestoreInstanceState(savedInstanceState) // If there was an upload in progress, get its reference and create a new StorageReference val stringRef = savedInstanceState.getString("reference") ?: return storageRef = Firebase.storage.getReferenceFromUrl(stringRef) // Find all UploadTasks under this StorageReference (in this example, there should be one) val tasks = storageRef.activeUploadTasks if (tasks.size > 0) { // Get the task monitoring the upload val task = tasks[0] // Add new listeners to the task using an Activity scope task.addOnSuccessListener(this) { // Success! // ... } } }
Java
@Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); // If there's an upload in progress, save the reference so you can query it later if (mStorageRef != null) { outState.putString("reference", mStorageRef.toString()); } } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState); // If there was an upload in progress, get its reference and create a new StorageReference final String stringRef = savedInstanceState.getString("reference"); if (stringRef == null) { return; } mStorageRef = FirebaseStorage.getInstance().getReferenceFromUrl(stringRef); // Find all UploadTasks under this StorageReference (in this example, there should be one) List<UploadTask> tasks = mStorageRef.getActiveUploadTasks(); if (tasks.size() > 0) { // Get the task monitoring the upload UploadTask task = tasks.get(0); // Add new listeners to the task using an Activity scope task.addOnSuccessListener(this, new OnSuccessListener<UploadTask.TaskSnapshot>() { @Override public void onSuccess(UploadTask.TaskSnapshot state) { // Success! // ... } }); } }
getActiveUploadTasks
ruft alle aktiven Uploadaufgaben unter und unter dem
Referenz bereitgestellt, sodass Sie möglicherweise mehrere Aufgaben erledigen müssen.
Uploads bei Prozessneustarts fortsetzen
Wenn der Prozess beendet wird, werden alle laufenden Uploads unterbrochen. Du kannst den Upload jedoch fortsetzen, nachdem der Prozess neu gestartet wurde, indem du Upload-Sitzung mit dem Server. So sparen Sie Zeit und Bandbreite, da Sie den Upload vom Anfang der Datei an.
Starte dazu den Upload über putFile
. Für das resultierende StorageTask
getUploadSessionUri
aufrufen und den resultierenden Wert im nichtflüchtigen Speicher speichern
(z. B. SharedPreferences).
Kotlin+KTX
uploadTask = storageRef.putFile(localFile) uploadTask.addOnProgressListener { taskSnapshot -> sessionUri = taskSnapshot.uploadSessionUri if (sessionUri != null && !saved) { saved = true // A persisted session has begun with the server. // Save this to persistent storage in case the process dies. } }
Java
uploadTask = mStorageRef.putFile(localFile); uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() { @Override public void onProgress(UploadTask.TaskSnapshot taskSnapshot) { Uri sessionUri = taskSnapshot.getUploadSessionUri(); if (sessionUri != null && !mSaved) { mSaved = true; // A persisted session has begun with the server. // Save this to persistent storage in case the process dies. } } });
Nachdem der Prozess mit einem unterbrochenen Upload neu gestartet wurde, rufen Sie putFile noch einmal auf. Aber dieses Mal auch den gespeicherten URI übergeben.
Kotlin+KTX
// resume the upload task from where it left off when the process died. // to do this, pass the sessionUri as the last parameter uploadTask = storageRef.putFile( localFile, storageMetadata { }, sessionUri, )
Java
//resume the upload task from where it left off when the process died. //to do this, pass the sessionUri as the last parameter uploadTask = mStorageRef.putFile(localFile, new StorageMetadata.Builder().build(), sessionUri);
Die Sitzungen dauern eine Woche. Wenn Sie versuchen, eine Sitzung fortzusetzen, abgelaufen ist oder ein Fehler aufgetreten ist, erhalten Sie einen fehlgeschlagenen Rückruf. Sie sind dafür verantwortlich, dass die Datei zwischen den Uploads nicht geändert wird.
Fehlerbehandlung
Fehler beim Hochladen können verschiedene Ursachen haben, Die lokale Datei ist nicht vorhanden oder der Nutzer hat keine Berechtigung zum Hochladen. auf die gewünschte Datei. Weitere Informationen zu Fehlern finden Sie in der Fehler beheben der Dokumentation.
Vollständiges Beispiel
Unten siehst du ein vollständiges Beispiel für einen Upload mit Fortschrittsüberwachung und Fehlerbehandlung:
Kotlin+KTX
// File or Blob file = Uri.fromFile(File("path/to/mountains.jpg")) // Create the file metadata metadata = storageMetadata { contentType = "image/jpeg" } // Upload file and metadata to the path 'images/mountains.jpg' uploadTask = storageRef.child("images/${file.lastPathSegment}").putFile(file, metadata) // Listen for state changes, errors, and completion of the upload. // You'll need to import com.google.firebase.storage.component1 and // com.google.firebase.storage.component2 uploadTask.addOnProgressListener { (bytesTransferred, totalByteCount) -> val progress = (100.0 * bytesTransferred) / totalByteCount Log.d(TAG, "Upload is $progress% done") }.addOnPausedListener { Log.d(TAG, "Upload is paused") }.addOnFailureListener { // Handle unsuccessful uploads }.addOnSuccessListener { // Handle successful uploads on complete // ... }
Java
// File or Blob file = Uri.fromFile(new File("path/to/mountains.jpg")); // Create the file metadata metadata = new StorageMetadata.Builder() .setContentType("image/jpeg") .build(); // Upload file and metadata to the path 'images/mountains.jpg' uploadTask = storageRef.child("images/"+file.getLastPathSegment()).putFile(file, metadata); // Listen for state changes, errors, and completion of the upload. uploadTask.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() { @Override public void onProgress(UploadTask.TaskSnapshot taskSnapshot) { double progress = (100.0 * taskSnapshot.getBytesTransferred()) / taskSnapshot.getTotalByteCount(); Log.d(TAG, "Upload is " + progress + "% done"); } }).addOnPausedListener(new OnPausedListener<UploadTask.TaskSnapshot>() { @Override public void onPaused(UploadTask.TaskSnapshot taskSnapshot) { Log.d(TAG, "Upload is paused"); } }).addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception exception) { // Handle unsuccessful uploads } }).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() { @Override public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) { // Handle successful uploads on complete // ... } });
Nachdem Sie Dateien hochgeladen haben, erfahren Sie nun, wie Sie sie von Cloud Storage herunterladen.