Google is committed to advancing racial equity for Black communities. See how.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Laden Sie Dateien auf Android hoch

Mit Cloud Storage können Entwickler schnell und einfach Dateien in einen von Firebase bereitgestellten und verwalteten Google Cloud Storage- Bucket hochladen.

Daten hochladen

Um eine Datei in den Cloud-Speicher hochzuladen, erstellen Sie zunächst einen Verweis auf den vollständigen Pfad der Datei, einschließlich des Dateinamens.

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

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

Sobald Sie eine entsprechende Referenz erstellt haben, rufen Sie die putBytes() , putFile() oder putStream() auf, um die Datei in den Cloud-Speicher hochzuladen.

Sie können keine Daten mit einem Verweis auf das Stammverzeichnis Ihres Google Cloud Storage- Buckets hochladen. Ihre Referenz muss auf eine untergeordnete URL verweisen.

Hochladen von Daten im Speicher

Die putBytes() -Methode ist der einfachste Weg, eine Datei in den Cloud-Speicher hochzuladen. putBytes() nimmt ein byte[] und gibt eine UploadTask , mit der Sie den Status des Uploads verwalten und überwachen können.

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.
        // ...
    }
});

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.
    // ...
}

Da putBytes() ein byte[] akzeptiert, muss Ihre App den gesamten Inhalt einer Datei auf einmal im Speicher halten. Verwenden Sie putStream() oder putFile() , um weniger Speicher zu verwenden.

Von einem Stream hochladen

Die putStream() -Methode ist die vielseitigste Methode zum Hochladen einer Datei in den Cloud-Speicher. putStream() einen InputStream und gibt eine UploadTask , mit der Sie den Status des Uploads verwalten und überwachen können.

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.
        // ...
    }
});

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.
    // ...
}

Hochladen aus einer lokalen Datei

Mit der putFile() -Methode können Sie lokale Dateien wie Fotos und Videos von der Kamera auf das Gerät hochladen. putFile() nimmt eine File und gibt eine UploadTask der Sie den Status des Uploads verwalten und überwachen können.

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.
        // ...
    }
});

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.
    // ...
}

Holen Sie sich eine Download-URL

Nach dem Hochladen einer Datei können Sie eine URL zum Herunterladen der Datei getDownloadUrl() indem Sie die Methode getDownloadUrl() in StorageReference :

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
            // ...
        }
    }
});

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
        // ...
    }
}

Dateimetadaten hinzufügen

Sie können beim Hochladen von Dateien auch Metadaten einschließen. Diese Metadaten enthalten typische Dateimetadateneigenschaften wie name , size und contentType (im Allgemeinen als MIME-Typ bezeichnet). Die putFile() Methode schließt automatisch den MIME - Typ der File - Erweiterung, aber Sie können die automatisch ermittelten Typ überschreiben , indem die Angabe contentType in den Metadaten. Wenn Sie keinen contentType und Cloud Storage keinen Standard aus der Dateierweiterung ableiten kann, verwendet Cloud Storage application/octet-stream . Weitere Informationen zu Dateimetadaten finden Sie im Abschnitt Verwenden von Dateimetadaten .

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);

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)

Uploads verwalten

Zusätzlich zum Starten von Uploads können Sie Uploads mit den Methoden pause() , resume() und cancel() anhalten, fortsetzen und cancel() . Ereignisse zum Anhalten und Fortsetzen lösen Änderungen des pause bzw. progress aus. Das Abbrechen eines Uploads führt dazu, dass der Upload fehlschlägt und ein Fehler angezeigt wird, der darauf hinweist, dass der Upload abgebrochen wurde.

Java

uploadTask = storageRef.child("images/mountains.jpg").putFile(file);

// Pause the upload
uploadTask.pause();

// Resume the upload
uploadTask.resume();

// Cancel the upload
uploadTask.cancel();

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()

Überwachen Sie den Upload-Fortschritt

Sie können Listener hinzufügen, um Erfolg, Misserfolg, Fortschritt oder Pausen in Ihrer Upload-Aufgabe zu behandeln:

Listener-Typ Typische Verwendung
OnProgressListener Dieser Listener wird während der Datenübertragung regelmäßig aufgerufen und kann zum Auffüllen eines Upload- / Download-Indikators verwendet werden.
OnPausedListener Dieser Listener wird jedes Mal aufgerufen, wenn die Aufgabe angehalten wird.
OnSuccessListener Dieser Listener wird aufgerufen, wenn die Aufgabe erfolgreich abgeschlossen wurde.
OnFailureListener Dieser Listener wird immer dann aufgerufen, wenn der Upload fehlgeschlagen ist. Dies kann aufgrund von Netzwerk-Timeouts, Autorisierungsfehlern oder wenn Sie die Aufgabe abbrechen, geschehen.

OnFailureListener wird mit einer Exception Instanz aufgerufen. Andere Listener werden mit einem UploadTask.TaskSnapshot Objekt UploadTask.TaskSnapshot . Dieses Objekt ist eine unveränderliche Ansicht der Aufgabe zum Zeitpunkt des Ereignisses. Ein UploadTask.TaskSnapshot enthält die folgenden Eigenschaften:

Eigentum Art Beschreibung
getDownloadUrl String Eine URL, über die das Objekt heruntergeladen werden kann. Dies ist eine öffentliche, nicht erratbare URL, die für andere Clients freigegeben werden kann. Dieser Wert wird ausgefüllt, sobald ein Upload abgeschlossen ist.
getError Exception Wenn die Aufgabe fehlgeschlagen ist, hat dies die Ursache als Ausnahme.
getBytesTransferred long Die Gesamtzahl der Bytes, die übertragen wurden, als dieser Snapshot erstellt wurde.
getTotalByteCount long Die Gesamtzahl der Bytes, die hochgeladen werden sollen.
getUploadSessionUri String Ein URI, mit dem diese Aufgabe über einen weiteren Aufruf von putFile fortgesetzt werden kann.
getMetadata StorageMetadata Bevor ein Upload abgeschlossen ist, werden die Metadaten an den Server gesendet. Nach Abschluss des Uploads sind dies die vom Server zurückgegebenen Metadaten.
getTask UploadTask Die Aufgabe, die diesen Snapshot erstellt hat. Verwenden Sie diese Aufgabe, um den Upload abzubrechen, anzuhalten oder fortzusetzen.
getStorage StorageReference Die StorageReference , mit der die UploadTask .

Die UploadTask Ereignis-Listener bieten eine einfache und leistungsstarke Möglichkeit, Upload-Ereignisse zu überwachen.

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");
    }
});

Kotlin + KTX

// Observe state change events such as progress, pause, and resume
// You'll need to import com.google.firebase.storage.ktx.component1 and 
// com.google.firebase.storage.ktx.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")
}

Änderungen des Aktivitätslebenszyklus behandeln

Das Hochladen wird auch nach Änderungen des Aktivitätslebenszyklus im Hintergrund fortgesetzt (z. B. Anzeigen eines Dialogfelds oder Drehen des Bildschirms). Alle Hörer, die Sie angehängt haben, bleiben ebenfalls angehängt. Dies kann zu unerwarteten Ergebnissen führen, wenn sie nach Beendigung der Aktivität aufgerufen werden.

Sie können dieses Problem lösen, indem Sie Ihre Listener mit einem Aktivitätsbereich abonnieren, um die Registrierung automatisch aufzuheben, wenn die Aktivität beendet wird. Verwenden getActiveUploadTasks dann beim Neustart der Aktivität die Methode getActiveUploadTasks , um Upload-Aufgaben getActiveUploadTasks , die noch ausgeführt werden oder kürzlich abgeschlossen wurden.

Das folgende Beispiel zeigt dies und zeigt auch, wie der verwendete Speicherreferenzpfad beibehalten wird.

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!
                // ...
            }
        });
    }
}

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!
            // ...
        }
    }
}

getActiveUploadTasks ruft alle aktiven Upload-Aufgaben unter und unter der angegebenen Referenz ab, sodass Sie möglicherweise mehrere Aufgaben ausführen müssen.

Fortlaufende Uploads über Prozessneustarts hinweg

Wenn Ihr Prozess heruntergefahren wird, werden alle laufenden Uploads unterbrochen. Sie können den Upload jedoch nach dem Neustart des Prozesses fortsetzen, indem Sie die Upload-Sitzung mit dem Server fortsetzen. Dies kann Zeit und Bandbreite sparen, indem der Upload nicht am Anfang der Datei gestartet wird.

Beginnen Sie dazu mit dem Hochladen über putFile . getUploadSessionUri Sie in der resultierenden StorageTask getUploadSessionUri und speichern Sie den resultierenden Wert im persistenten Speicher (z. B. SharedPreferences).

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.
        }
    }
});

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.
    }
}

Rufen Sie putFile erneut auf, nachdem Ihr Prozess mit einem unterbrochenen Upload neu gestartet wurde. Aber diesmal geht auch der gerettete Uri vorbei.

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);

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)

Die Sitzungen dauern eine Woche. Wenn Sie versuchen, eine Sitzung nach Ablauf fortzusetzen, oder wenn ein Fehler aufgetreten ist, erhalten Sie einen Fehlerrückruf. Es liegt in Ihrer Verantwortung sicherzustellen, dass sich die Datei zwischen den Uploads nicht geändert hat.

Fehlerbehandlung

Es gibt eine Reihe von Gründen, warum beim Hochladen Fehler auftreten können, einschließlich der nicht vorhandenen lokalen Datei oder der Tatsache, dass der Benutzer keine Berechtigung zum Hochladen der gewünschten Datei hat. Sie können mehr Informationen über Fehler in dem finden Handle Fehler Abschnitt der Dokumentation.

Vollständiges Beispiel

Ein vollständiges Beispiel für einen Upload mit Fortschrittsüberwachung und Fehlerbehandlung ist unten dargestellt:

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
        // ...
    }
});

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.ktx.component1 and 
// com.google.firebase.storage.ktx.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
    // ...
}

Nachdem Sie die Dateien hochgeladen haben, erfahren Sie, wie Sie sie aus dem Cloud-Speicher herunterladen .