Cloud Storage dla Firebase umożliwia szybkie i łatwe przesyłanie plików do zasobnika Cloud Storage udostępnianego i zarządzanego przez Firebase.
Prześlij pliki
Aby przesłać plik do Cloud Storage, najpierw utwórz odwołanie do pełnej ścieżki pliku, w tym jego nazwy.
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
Gdy utworzysz odpowiednie odwołanie, wywołaj metodę putBytes()
, putFile()
lub putStream()
, aby przesłać plik do Cloud Storage.
Nie możesz przesłać danych odwołujących się do katalogu głównego zasobnika Cloud Storage. Odwołanie musi wskazywać podrzędny URL.
Prześlij z danych w pamięci
Metoda putBytes()
to najprostszy sposób przesyłania pliku do Cloud Storage. putBytes()
pobiera byte[]
i zwraca UploadTask
, którego można używać do zarządzania stanem przesyłania i monitorowania tego stanu.
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. // ... } });
putBytes()
akceptuje konstrukcję byte[]
, dlatego aplikacja wymaga od razu przechowywania całej zawartości pliku w pamięci. Aby ograniczyć wykorzystanie pamięci, rozważ użycie putStream()
lub putFile()
.
Przesyłanie ze strumienia
Metoda putStream()
to najbardziej uniwersalny sposób przesyłania plików do Cloud Storage. putStream()
pobiera InputStream
i zwraca UploadTask
, którego można używać do zarządzania stanem przesyłania i monitorowania tego stanu.
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. // ... } });
Prześlij z pliku lokalnego
Metoda putFile()
umożliwia przesyłanie plików lokalnych z urządzenia, np. zdjęć i filmów z aparatu. putFile()
pobiera File
i zwraca UploadTask
, którego możesz używać do zarządzania stanem przesyłania i monitorowania tego stanu.
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. // ... } });
Uzyskiwanie adresu URL pobierania
Po przesłaniu pliku możesz uzyskać adres URL umożliwiający jego pobranie, wywołując w StorageReference
metodę getDownloadUrl()
:
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 // ... } } });
Dodaj metadane pliku
Możesz też dołączyć metadane podczas przesyłania plików.
Zawierają one typowe właściwości metadanych plików, takie jak name
, size
i contentType
(powszechnie nazywane typem MIME). Metoda putFile()
automatycznie określa typ MIME na podstawie rozszerzenia File
, ale możesz zastąpić ten wykryty automatycznie typ, podając w metadanych contentType
. Jeśli nie podasz contentType
, a Cloud Storage nie będzie w stanie ustalić wartości domyślnej na podstawie rozszerzenia pliku, Cloud Storage użyje application/octet-stream
. Więcej informacji o metadanych pliku znajdziesz w sekcji Używanie metadanych pliku.
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);
Zarządzaj przesyłaniem
Oprócz rozpoczynania przesyłania możesz wstrzymywać, wznawiać i anulować przesyłanie, korzystając z metod pause()
, resume()
i cancel()
. Zmiany stanu wstrzymywania i wznawiania zdarzeń
wzrostu wartości pause
i progress
. Anulowanie przesyłania spowoduje, że zakończy się ono niepowodzeniem i wyświetli się komunikat o błędzie informujący o tym, że przesyłanie zostało anulowane.
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();
Monitorowanie postępu przesyłania
Możesz dodać detektory, które będą obsługiwać przesyłanie:
Typ detektora | Typowe zastosowanie |
---|---|
OnProgressListener |
Ten detektor jest wywoływany okresowo w miarę przesyłania danych i może służyć do wypełniania wskaźnika przesyłania/pobierania. |
OnPausedListener |
Ten detektor jest wywoływany za każdym razem, gdy zadanie zostanie wstrzymane. |
OnSuccessListener |
Ten detektor jest wywoływany po ukończeniu zadania. |
OnFailureListener |
Ten detektor jest wywoływany za każdym razem, gdy przesyłanie się nie uda. Może to wynikać z przekroczenia limitu czasu sieci, błędów autoryzacji lub anulowania zadania. |
Funkcja OnFailureListener
jest wywoływana za pomocą instancji Exception
. Inne detektory są wywoływane za pomocą obiektu UploadTask.TaskSnapshot
.
Ten obiekt jest stałym widokiem zadania w momencie wystąpienia zdarzenia.
Element UploadTask.TaskSnapshot
zawiera te właściwości:
Właściwość | Typ | Opis |
---|---|---|
getDownloadUrl |
String |
Adres URL, za pomocą którego można pobrać obiekt. To jest publiczny, niemożliwe do odgadnięcia adres URL, który można udostępnić innym klientom. Ta wartość jest wypełniana po zakończeniu przesyłania. |
getError |
Exception |
Jeśli zadanie się nie udało, jako wyjątek będzie widoczna przyczyna. |
getBytesTransferred |
long |
Łączna liczba bajtów, które zostały przesłane podczas wykonywania tego zrzutu. |
getTotalByteCount |
long |
Oczekiwana liczba bajtów do przesłania. |
getUploadSessionUri |
String |
Identyfikator URI, którego można użyć do kontynuowania tego zadania przez kolejne wywołanie do putFile. |
getMetadata |
StorageMetadata |
Zanim przesyłanie się zakończy, te metadane są wysyłane na serwer. Po zakończeniu przesyłania te metadane zwrócone przez serwer. |
getTask |
UploadTask |
Zadanie, które utworzyło ten zrzut. Wykonaj to zadanie, aby anulować, wstrzymać lub wznowić przesyłanie. |
getStorage |
StorageReference |
Element StorageReference użyty do utworzenia UploadTask . |
Detektory zdarzeń UploadTask
pozwalają w prosty i zaawansowany sposób monitorować przesyłane zdarzenia.
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"); } });
Obsługa zmian w cyklu życia aktywności
Przesyłanie plików jest kontynuowane w tle nawet po zmianie cyklu życia aktywności (np. wyświetleniu okna lub obróceniu ekranu). Wszystkie podłączone detektory również pozostaną dołączone. Może to spowodować nieoczekiwane wywołania po zatrzymaniu aktywności.
Aby rozwiązać ten problem, zasubskrybuj detektorów z zakresem aktywności, aby automatycznie wyrejestrowały ich po zatrzymaniu. Następnie użyj metody getActiveUploadTasks
po ponownym uruchomieniu działania, aby uzyskać zadania przesyłania, które są nadal uruchomione lub niedawno zakończone.
Poniższy przykład obrazuje to i pokazuje, jak utrwalać używaną ścieżkę referencyjną do przechowywania danych.
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
pobiera wszystkie aktywne zadania przesyłania z podanego pliku referencyjnego i pod nim, więc może być konieczne wykonanie wielu zadań.
Ponowne uruchamianie kolejnych procesów przesyłania
Jeśli Twój proces się zakończy, wszystkie trwające operacje przesyłania zostaną przerwane. Możesz jednak kontynuować przesyłanie po ponownym uruchomieniu procesu, wznawiając sesję przesyłania z serwerem. Może to zaoszczędzić czas i przepustowość, ponieważ nie rozpoczyna przesyłania od początku pliku.
W tym celu rozpocznij przesyłanie za pomocą usługi putFile
. W wynikowym StorageTask
wywołaj getUploadSessionUri
i zapisz wartość w pamięci trwałej (np. 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. } } });
Po ponownym uruchomieniu procesu i przerwaniu przesyłania wywołaj ponownie putFile. Tym razem jednak pomiń zapisany identyfikator URI.
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);
Sesje miały miejsce w ciągu ostatniego tygodnia. Jeśli spróbujesz wznowić sesję po jej wygaśnięciu lub wystąpił błąd, otrzymasz wywołanie zwrotne o niepowodzeniu. Twoim obowiązkiem jest dopilnowanie, aby plik nie został zmieniony przed przesłaniem.
Obsługa błędów
Błędy mogą występować przy przesyłaniu z różnych powodów, np. gdy plik lokalny nie istnieje lub użytkownik nie ma uprawnień do przesłania żądanego pliku. Więcej informacji o błędach znajdziesz w dokumentacji w sekcji Obsługa błędów.
Pełny przykład
Pełny przykład przesyłania z monitorowaniem postępu i obsługą błędów znajdziesz poniżej:
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 // ... } });
Dowiedz się, jak pobrać je z Cloud Storage.