firebase - files - getdownloadurl
¿Cómo obtener una lista de todos los archivos en Cloud Storage en una aplicación Firebase? (17)
A partir de mayo de 2019, la
versión 6.1.0
de Firebase SDK para Cloud Storage ahora admite la lista de todos los objetos de un depósito.
Simplemente necesita llamar a
listAll()
en una
Reference
:
// Firebase services
var database: FIRDatabase!
var storage: FIRStorage!
...
// Initialize Database, Auth, Storage
database = FIRDatabase.database()
storage = FIRStorage.storage()
...
// Initialize an array for your pictures
var picArray: [UIImage]()
Tenga en
cuenta
que para utilizar esta función, debe optar por la
versión 2 de las Reglas de seguridad
, que se puede hacer haciendo
rules_version = ''2'';
La primera línea de sus reglas de seguridad:
let fileData = NSData() // get data...
let storageRef = storage.reference().child("myFiles/myFile")
storageRef.putData(fileData).observeStatus(.Success) { (snapshot) in
// When the image has successfully uploaded, we get it''s download URL
let downloadURL = snapshot.metadata?.downloadURL()?.absoluteString
// Write the download URL to the Realtime Database
let dbRef = database.reference().child("myFiles/myFile")
dbRef.setValue(downloadURL)
}
Recomiendo consultar los docs para mayor referencia.
Además, de acuerdo con la
setup
, en el Paso 5, este script no está permitido para
Node.js
ya que
require("firebase/app");
no devolverá
firebase.storage()
como una función.
Esto solo se logra usando
import * as firebase from ''firebase/app'';
.
Estoy trabajando en cargar imágenes, todo funciona muy bien, pero tengo 100 imágenes y me gustaría mostrarlas todas en mi
View
, ya que obtengo la lista completa de las imágenes en una carpeta, no puedo encontrar ninguna API para este trabajo.
Ampliando la respuesta de Rosário Pereira Fernandes , para una solución de JavaScript:
- Instale firebase en su máquina
npm install -g firebase-tools
-
En firebase init, configure
JavaScriptcomo idioma predeterminado - En la carpeta raíz del proyecto creado, ejecute las instalaciones de npm
npm install --save firebase
npm install @google-cloud/storage
npm install @google-cloud/firestore
... <any other dependency needed>
- Agregue dependencias no predeterminadas en su proyecto como
"firebase": "^6.3.3",
"@google-cloud/storage": "^3.0.3"
funciones / paquete.json
{
"name": "functions",
"description": "Cloud Functions for Firebase",
"scripts": {
"lint": "eslint .",
"serve": "firebase serve --only functions",
"shell": "firebase functions:shell",
"start": "npm run shell",
"deploy": "firebase deploy --only functions",
"logs": "firebase functions:log"
},
"engines": {
"node": "10"
},
"dependencies": {
"@google-cloud/storage": "^3.0.3",
"firebase": "^6.3.3",
"firebase-admin": "^8.0.0",
"firebase-functions": "^3.1.0"
},
"devDependencies": {
"eslint": "^5.12.0",
"eslint-plugin-promise": "^4.0.1",
"firebase-functions-test": "^0.1.6"
},
"private": true
}
-
Crear una especie de lista
listAllfunción
index.js
var serviceAccount = require("./key.json");
const functions = require(''firebase-functions'');
const images = require(''./images.js'');
var admin = require("firebase-admin");
admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
databaseURL: "https://<my_project>.firebaseio.com"
});
const bucket = admin.storage().bucket(''<my_bucket>.appspot.com'')
exports.getImages = functions.https.onRequest((request, response) => {
images.getImages(bucket)
.then(urls => response.status(200).send({ data: { urls } }))
.catch(err => console.error(err));
})
images.js
module.exports = {
getImages
}
const query = {
directory: ''images''
};
function getImages(bucket) {
return bucket.getFiles(query)
.then(response => getUrls(response))
.catch(err => console.error(err));
}
function getUrls(response) {
const promises = []
response.forEach( files => {
files.forEach (file => {
promises.push(getSignedUrl(file));
});
});
return Promise.all(promises).then(result => getParsedUrls(result));
}
function getSignedUrl(file) {
return file.getSignedUrl({
action: ''read'',
expires: ''09-01-2019''
})
}
function getParsedUrls(result) {
return JSON.stringify(result.map(mediaLink => createMedia(mediaLink)));
}
function createMedia(mediaLink) {
const reference = {};
reference.mediaLink = mediaLink[0];
return reference;
}
-
Ejecute la
firebase deploypara cargar su función en la nube - Call su función personalizada desde su aplicación
build.gradle
dependencies {
...
implementation ''com.google.firebase:firebase-functions:18.1.0''
...
}
clase kotlin
private val functions = FirebaseFunctions.getInstance()
val cloudFunction = functions.getHttpsCallable("getImages")
cloudFunction.call().addOnSuccessListener {...}
Con respecto al desarrollo posterior de esta función, me encontré con algunos problemas que podrían encontrarse here .
Así que tuve un proyecto que requería descargar activos del almacenamiento de Firebase, así que tuve que resolver este problema yo mismo. Aquí es cómo :
1- Primero, crea un modelo de datos, por ejemplo,
class Choice{}
, en esa clase se define una variable de cadena llamada Nombre de imagen para que sea así
class Choice {
.....
String imageName;
}
2- desde una base de datos / base de datos firebase, vaya y codifique los nombres de las imágenes a los objetos, así que si tiene un nombre de imagen llamado Apple.png, cree el objeto para que sea
Choice myChoice = new Choice(...,....,"Apple.png");
3- Ahora, obtenga el enlace para los activos en su almacenamiento de Firebase que será algo así
gs://your-project-name.appspot.com/
4- finalmente, inicialice su referencia de almacenamiento de Firebase y comience a obtener los archivos por un ciclo como ese
storageRef = storage.getReferenceFromUrl(firebaseRefURL).child(imagePath);
File localFile = File.createTempFile("images", "png");
storageRef.getFile(localFile).addOnSuccessListener(new OnSuccessListener<FileDownloadTask.TaskSnapshot>() {
@Override
public void onSuccess(FileDownloadTask.TaskSnapshot taskSnapshot) {
//Dismiss Progress Dialog//
}
5- eso es todo
Como no hay ningún idioma en la lista, responderé esto en Swift. Recomendamos usar Firebase Storage y Firebase Realtime Database juntos para lograr listas de descargas:
Compartido:
let dbRef = database.reference().child("myFiles")
dbRef.observeEventType(.ChildAdded, withBlock: { (snapshot) in
// Get download URL from snapshot
let downloadURL = snapshot.value() as! String
// Create a storage reference from the URL
let storageRef = storage.referenceFromURL(downloadURL)
// Download the data, assuming a max size of 1MB (you can change this as necessary)
storageRef.dataWithMaxSize(1 * 1024 * 1024) { (data, error) -> Void in
// Create a UIImage, add it to the array
let pic = UIImage(data: data)
picArray.append(pic)
})
})
Subir:
// Since you mentioned your images are in a folder,
// we''ll create a Reference to that folder:
var storageRef = firebase.storage().ref("your_folder");
// Now we get the references of these images
storageRef.listAll().then(function(result) {
result.items.forEach(function(imageRef) {
// And finally display them
displayImage(imageRef);
});
}).catch(function(error) {
// Handle any errors
});
function displayImage(imageRef) {
imageRef.getDownloadURL().then(function(url) {
// TODO: Display the image on the UI
}).catch(function(error) {
// Handle any errors
});
}
Descargar:
rules_version = ''2'';
service firebase.storage {
match /b/{bucket}/o {
match /{allPaths=**} {
Para obtener más información, vea Zero to App: Develop with Firebase , y su código fuente asociado , para un ejemplo práctico de cómo hacerlo.
Dado que los SDK de Firebase para JavaScript versión 6.1 , iOS versión 6.4 y Android versión 18.1 tienen un método para listar archivos.
La documentation es un poco escasa hasta ahora, por lo que recomiendo revisar la respuesta de Rosário para más detalles.
Respuesta anterior, ya que este enfoque todavía puede ser útil a veces:
Actualmente no hay una llamada API en Firebase SDK para enumerar todos los archivos en una carpeta de Cloud Storage desde una aplicación. Si necesita dicha funcionalidad, debe almacenar los metadatos de los archivos (como las URL de descarga) en un lugar donde pueda enumerarlos. Firebase Realtime Database y Cloud Firestore son perfectos para esto y le permite compartir fácilmente las URL con otros.
Puede encontrar una buena (pero algo complicada) muestra de esto en nuestra aplicación de muestra FriendlyPix . El código relevante para la versión web está here , pero también hay versiones para iOS y Android.
En realidad, esto es posible, pero solo con una API de Google Cloud en lugar de una de Firebase. Esto se debe a que Firebase Storage es un Google Cloud Storage Bucket al que se puede llegar fácilmente con las API de Google Cloud, sin embargo, debe usar OAuth para la autenticación en lugar de Firebase.
Me enfrenté al mismo problema, el mío es aún más complicado.
El administrador cargará archivos de audio y pdf en el almacenamiento:
-
audios / season1, season2 ... / class1, class 2 / .mp3 archivos
-
libros / archivos .pdf
La aplicación de Android necesita obtener la lista de subcarpetas y archivos.
La solución es detectar el evento de carga en el almacenamiento y crear la misma estructura en el almacén de incendios mediante la función de nube.
Paso 1: Cree manualmente la colección de ''almacenamiento'' y el documento ''audios / books'' en firestore
Paso 2: configurar la función de nube
Puede tomar alrededor de 15 minutos: https://www.youtube.com/watch?v=DYfP-UIKxH0&list=PLl-K7zZEsYLkPZHe41m4jfAxUi0JjLgSM&index=1
Paso 3: captura el evento de carga con la función de nube
import * as functions from ''firebase-functions'';
import * as admin from ''firebase-admin'';
admin.initializeApp(functions.config().firebase);
const path = require(''path'');
export const onFileUpload = functions.storage.object().onFinalize(async (object) => {
let filePath = object.name; // File path in the bucket.
const contentType = object.contentType; // File content type.
const metageneration = object.metageneration; // Number of times metadata has been generated. New objects have a value of 1.
if (metageneration !== "1") return;
// Get the file name.
const fileName = path.basename(filePath);
filePath = filePath.substring(0, filePath.length - 1);
console.log(''contentType '' + contentType);
console.log(''fileName '' + fileName);
console.log(''filePath '' + filePath);
console.log(''path.dirname(filePath) '' + path.dirname(filePath));
filePath = path.dirname(filePath);
const pathArray = filePath.split("/");
let ref = '''';
for (const item of pathArray) {
if (ref.length === 0) {
ref = item;
}
else {
ref = ref.concat(''/sub/'').concat(item);
}
}
ref = ''storage/''.concat(ref).concat(''/sub'')
admin.firestore().collection(ref).doc(fileName).create({})
.then(result => {console.log(''onFileUpload:updated'')})
.catch(error => {
console.log(error);
});
});
Paso 4: Recupere la lista de carpetas / archivos en la aplicación de Android usando firestore
private static final String STORAGE_DOC = "storage/";
public static void getMediaCollection(String path, OnCompleteListener onCompleteListener) {
String[] pathArray = path.split("/");
String doc = null;
for (String item : pathArray) {
if (TextUtils.isEmpty(doc)) doc = STORAGE_DOC.concat(item);
else doc = doc.concat("/sub/").concat(item);
}
doc = doc.concat("/sub");
getFirestore().collection(doc).get().addOnCompleteListener(onCompleteListener);
}
Paso 5: Obtenga la URL de descarga
public static void downloadMediaFile(String path, OnCompleteListener<Uri> onCompleteListener) {
getStorage().getReference().child(path).getDownloadUrl().addOnCompleteListener(onCompleteListener);
}
Nota
Tenemos que poner la colección "sub" a cada elemento, ya que firestore no admite recuperar la lista de la colección.
Me llevó 3 días encontrar la solución, espero que te lleve 3 horas como máximo.
Salud.
Para Android, la mejor práctica es usar FirebaseUI y Glide.
Debe agregar eso en su gradle / aplicación para obtener la biblioteca. ¡Tenga en cuenta que ya tiene Glide!
implementation ''com.firebaseui:firebase-ui-storage:4.1.0''
Y luego en tu código usa
// Reference to an image file in Cloud Storage
StorageReference storageReference = FirebaseStorage.getInstance().getReference();
// ImageView in your Activity
ImageView imageView = findViewById(R.id.imageView);
// Download directly from StorageReference using Glide
// (See MyAppGlideModule for Loader registration)
GlideApp.with(this /* context */)
.load(storageReference)
.into(imageView);
Para el nodo js, usé este código
const Storage = require(''@google-cloud/storage'');
const storage = new Storage({projectId: ''PROJECT_ID'', keyFilename: ''D://keyFileName.json''});
const bucket = storage.bucket(''project.appspot.com''); //gs://project.appspot.com
bucket.getFiles().then(results => {
const files = results[0];
console.log(''Total files:'', files.length);
files.forEach(file => {
file.download({destination: `D://${file}`}).catch(error => console.log(''Error: '', error))
});
}).catch(err => {
console.error(''ERROR:'', err);
});
Para hacer esto con JS
Puede agregarlos directamente a su contenedor div, o puede insertarlos en una matriz. A continuación se muestra cómo agregarlos a su div.
1) Cuando almacene sus imágenes en almacenamiento, cree una referencia a la imagen en su base de datos de Firebase con la siguiente estructura
/images/(imageName){
description: "" ,
imageSrc : (imageSource)
}
2) Cuando carga su documento, extraiga todas las URL de origen de imagen de la base de datos en lugar del almacenamiento con el siguiente código
$(document).ready(function(){
var query = firebase.database().ref(''images/'').orderByKey();
query.once("value").then(function(snapshot){
snapshot.forEach(function(childSnapshot){
var imageName = childSnapshot.key;
var childData = childSnapshot.val();
var imageSource = childData.url;
$(''#imageGallery'').append("<div><img src=''"+imageSource+"''/></div>");
})
})
});
Puede enumerar archivos en un directorio de almacenamiento de Firebase mediante el método listAll (). Para usar este método, debe implementar esta versión de almacenamiento de Firebase. ''com.google.firebase: firebase-storage: 18.1.1''
https://firebase.google.com/docs/storage/android/list-files
Tenga en cuenta que actualice las Reglas de seguridad a la versión 2.
Puedes usar el siguiente código. Aquí estoy cargando la imagen en el almacenamiento de Firebase y luego estoy almacenando la URL de descarga de la imagen en la base de datos de Firebase.
//getting the storage reference
StorageReference sRef = storageReference.child(Constants.STORAGE_PATH_UPLOADS + System.currentTimeMillis() + "." + getFileExtension(filePath));
//adding the file to reference
sRef.putFile(filePath)
.addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
@Override
public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
//dismissing the progress dialog
progressDialog.dismiss();
//displaying success toast
Toast.makeText(getApplicationContext(), "File Uploaded ", Toast.LENGTH_LONG).show();
//creating the upload object to store uploaded image details
Upload upload = new Upload(editTextName.getText().toString().trim(), taskSnapshot.getDownloadUrl().toString());
//adding an upload to firebase database
String uploadId = mDatabase.push().getKey();
mDatabase.child(uploadId).setValue(upload);
}
})
.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception exception) {
progressDialog.dismiss();
Toast.makeText(getApplicationContext(), exception.getMessage(), Toast.LENGTH_LONG).show();
}
})
.addOnProgressListener(new OnProgressListener<UploadTask.TaskSnapshot>() {
@Override
public void onProgress(UploadTask.TaskSnapshot taskSnapshot) {
//displaying the upload progress
double progress = (100.0 * taskSnapshot.getBytesTransferred()) / taskSnapshot.getTotalByteCount();
progressDialog.setMessage("Uploaded " + ((int) progress) + "%...");
}
});
Ahora para obtener todas las imágenes almacenadas en la base de datos de Firebase, puede usar
//adding an event listener to fetch values
mDatabase.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot snapshot) {
//dismissing the progress dialog
progressDialog.dismiss();
//iterating through all the values in database
for (DataSnapshot postSnapshot : snapshot.getChildren()) {
Upload upload = postSnapshot.getValue(Upload.class);
uploads.add(upload);
}
//creating adapter
adapter = new MyAdapter(getApplicationContext(), uploads);
//adding adapter to recyclerview
recyclerView.setAdapter(adapter);
}
@Override
public void onCancelled(DatabaseError databaseError) {
progressDialog.dismiss();
}
});
Para obtener más detalles, puede ver mi publicación Ejemplo de almacenamiento de Firebase .
También encontré este problema cuando estaba trabajando en mi proyecto. Realmente deseo que proporcionen un método de API final. De todos modos, así es como lo hice: cuando cargue una imagen en el almacenamiento de Firebase, cree un Objeto y pase este objeto a la base de datos de Firebase al mismo tiempo. Este objeto contiene el URI de descarga de la imagen.
trailsRef.putFile(file).addOnSuccessListener(new OnSuccessListener<UploadTask.TaskSnapshot>() {
@Override
public void onSuccess(UploadTask.TaskSnapshot taskSnapshot) {
Uri downloadUri = taskSnapshot.getDownloadUrl();
DatabaseReference myRef = database.getReference().child("trails").child(trail.getUnique_id()).push();
Image img = new Image(trail.getUnique_id(), downloadUri.toString());
myRef.setValue(img);
}
});
Más tarde, cuando desee descargar imágenes de una carpeta, simplemente recorra los archivos de esa carpeta. Esta carpeta tiene el mismo nombre que la "carpeta" en el almacenamiento de Firebase, pero puede nombrarlos como quiera. Los puse en hilo separado.
@Override
protected List<Image> doInBackground(Trail... params) {
String trialId = params[0].getUnique_id();
mDatabase = FirebaseDatabase.getInstance().getReference();
mDatabase.child("trails").child(trialId).addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(DataSnapshot dataSnapshot) {
images = new ArrayList<>();
Iterator<DataSnapshot> iter = dataSnapshot.getChildren().iterator();
while (iter.hasNext()) {
Image img = iter.next().getValue(Image.class);
images.add(img);
}
isFinished = true;
}
@Override
public void onCancelled(DatabaseError databaseError) {
}
});
Ahora tengo una lista de objetos que contienen los URI para cada imagen, puedo hacer lo que quiera hacer con ellos. Para cargarlos en imageView, creé otro hilo.
@Override
protected List<Bitmap> doInBackground(List<Image>... params) {
List<Bitmap> bitmaps = new ArrayList<>();
for (int i = 0; i < params[0].size(); i++) {
try {
URL url = new URL(params[0].get(i).getImgUrl());
Bitmap bmp = BitmapFactory.decodeStream(url.openConnection().getInputStream());
bitmaps.add(bmp);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return bitmaps;
}
Esto devuelve una lista de Bitmap, cuando termina simplemente los adjunto a ImageView en la actividad principal. Los siguientes métodos son @Override porque tengo interfaces creadas y escucho la finalización en otros hilos.
@Override
public void processFinishForBitmap(List<Bitmap> bitmaps) {
List<ImageView> imageViews = new ArrayList<>();
View v;
for (int i = 0; i < bitmaps.size(); i++) {
v = mInflater.inflate(R.layout.gallery_item, mGallery, false);
imageViews.add((ImageView) v.findViewById(R.id.id_index_gallery_item_image));
imageViews.get(i).setImageBitmap(bitmaps.get(i));
mGallery.addView(v);
}
}
Tenga en cuenta que primero tengo que esperar a que se devuelva la imagen de lista y luego llamar al hilo para que funcione en el mapa de bits de lista. En este caso, la imagen contiene el URI.
@Override
public void processFinish(List<Image> results) {
Log.e(TAG, "get back " + results.size());
LoadImageFromUrlTask loadImageFromUrlTask = new LoadImageFromUrlTask();
loadImageFromUrlTask.delegate = this;
loadImageFromUrlTask.execute(results);
}
Esperemos que alguien lo encuentre útil. También me servirá como una línea de hermandad en el futuro.
Una forma más de agregar la imagen a la base de datos usando la función de nube para rastrear cada imagen cargada y almacenarla en la base de datos.
exports.fileUploaded = functions.storage.object().onChange(event => {
const object = event.data; // the object that was just uploaded
const contentType = event.data.contentType; // This is the image Mimme type/
// Exit if this is triggered on a file that is not an image.
if (!contentType.startsWith(''image/'')) {
console.log(''This is not an image.'');
return null;
}
// Get the Signed URLs for the thumbnail and original image.
const config = {
action: ''read'',
expires: ''03-01-2500''
};
const bucket = gcs.bucket(event.data.bucket);
const filePath = event.data.name;
const file = bucket.file(filePath);
file.getSignedUrl(config, function(err, fileURL) {
console.log(fileURL);
admin.database().ref(''images'').push({
src: fileURL
});
});
});
Código completo aquí: https://gist.github.com/bossly/fb03686f2cb1699c2717a0359880cf84
Una solución alternativa puede ser crear un archivo (es decir, list.txt) sin nada dentro, en este archivo puede establecer los metadatos personalizados (es decir, un Mapa <Cadena, Cadena>) con la lista de todas las URL del archivo.
Entonces, si necesita descargar todos los archivos en un alimentador, primero descarga los metadatos del archivo list.txt, luego itera a través de los datos personalizados y descarga todos los archivos con las URL en el Mapa.
Desde marzo de 2017: con la adición de Firebase Cloud Functions y la integración más profunda de Firebase con Google Cloud, esto ahora es posible.
Con Cloud Functions puede usar el paquete Google Cloud Node para realizar operaciones épicas en Cloud Storage. A continuación se muestra un ejemplo que obtiene todas las URL de archivo en una matriz de Cloud Storage. Esta función se activará cada vez que algo se guarde en el almacenamiento en la nube de Google.
Nota 1 : Esta es una operación computacionalmente costosa, ya que tiene que recorrer todos los archivos en un bucket / carpeta.
Nota 2 : escribí esto solo como un ejemplo, sin poner mucho detalle en las promesas, etc. Solo para dar una idea.
const functions = require(''firebase-functions'');
const gcs = require(''@google-cloud/storage'')();
// let''s trigger this function with a file upload to google cloud storage
exports.fileUploaded = functions.storage.object().onChange(event => {
const object = event.data; // the object that was just uploaded
const bucket = gcs.bucket(object.bucket);
const signedUrlConfig = { action: ''read'', expires: ''03-17-2025'' }; // this is a signed url configuration object
var fileURLs = []; // array to hold all file urls
// this is just for the sake of this example. Ideally you should get the path from the object that is uploaded :)
const folderPath = "a/path/you/want/its/folder/size/calculated";
bucket.getFiles({ prefix: folderPath }, function(err, files) {
// files = array of file objects
// not the contents of these files, we''re not downloading the files.
files.forEach(function(file) {
file.getSignedUrl(signedUrlConfig, function(err, fileURL) {
console.log(fileURL);
fileURLs.push(fileURL);
});
});
});
});
Espero que esto te de la idea general. Para obtener mejores ejemplos de funciones en la nube, consulte el repositorio Github de Google lleno de ejemplos de funciones en la nube para Firebase . Consulte también su documentación de la API de Google Cloud Node
#In Python
import firebase_admin
from firebase_admin import credentials
from firebase_admin import storage
import datetime
import urllib.request
def image_download(url, name_img) :
urllib.request.urlretrieve(url, name_img)
cred = credentials.Certificate("credentials.json")
# Initialize the app with a service account, granting admin privileges
app = firebase_admin.initialize_app(cred, {
''storageBucket'': ''YOURSTORAGEBUCKETNAME.appspot.com'',
})
url_img = "gs://YOURSTORAGEBUCKETNAME.appspot.com/"
bucket_1 = storage.bucket(app=app)
image_urls = []
for blob in bucket_1.list_blobs():
name = str(blob.name)
#print(name)
blob_img = bucket_1.blob(name)
X_url = blob_img.generate_signed_url(datetime.timedelta(seconds = 300), method=''GET'')
#print(X_url)
image_urls.append(X_url)
PATH = [''Where you want to save the image'']
for path in PATH:
i = 1
for url in image_urls:
name_img = str(path + "image"+str(i)+".jpg")
image_download(url, name_img)
i+=1