मैं छवियों को अपलोड करने पर काम कर रहा हूं, सब कुछ बहुत अच्छा काम करता है, लेकिन मेरे पास 100 चित्र हैं और मैं उन सभी को अपने में दिखाना चाहूंगा View , क्योंकि मुझे एक फ़ोल्डर में छवियों की पूरी सूची मिलती है, मुझे इसके लिए कोई एपीआई नहीं मिल सकता है काम।
जवाबों:
जावास्क्रिप्ट रिलीज के लिए फायरबेस एसडीके के बाद से 6.1 , आईओएस रिलीज 6.4 , और एंड्रॉइड रिलीज संस्करण 18.1 सभी में फाइलों को सूचीबद्ध करने की एक विधि है।
प्रलेखन एक सा विरल अब तक है, इसलिए मैं बाहर की जाँच की सिफारिश Rosário के जवाब जानकारी के लिए।
पिछला उत्तर, क्योंकि यह दृष्टिकोण अभी भी कई बार उपयोगी हो सकता है:
वर्तमान में फायरबेस एसडीके में कोई भी एपीआई कॉल नहीं है जो किसी ऐप के भीतर से क्लाउड स्टोरेज फ़ोल्डर की सभी फाइलों को सूचीबद्ध करे। यदि आपको ऐसी कार्यक्षमता की आवश्यकता है, तो आपको फाइलों के मेटाडेटा (जैसे डाउनलोड यूआरएल) को उस स्थान पर संग्रहित करना चाहिए जहां आप उन्हें सूचीबद्ध कर सकते हैं। Firebase रीयलटाइम डाटाबेस और बादल के firestore इस के लिए एकदम सही हैं और आप भी आसानी से अन्य लोगों के साथ URL साझा कर सकते हैं।
आप हमारे FriendlyPix नमूना ऐप में इसका एक अच्छा (लेकिन कुछ हद तक शामिल) नमूना देख सकते हैं । वेब संस्करण के लिए प्रासंगिक कोड यहां है , लेकिन आईओएस और एंड्रॉइड के लिए भी संस्करण हैं।
मई 2019 तक, क्लाउड स्टोरेज के लिए फायरबेस एसडीके का संस्करण 6.1.0 अब एक बाल्टी से सभी वस्तुओं को सूचीबद्ध करने का समर्थन करता है। आपको बस listAll()एक कॉल करने की आवश्यकता है Reference:
// 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
});
}कृपया ध्यान दें कि इस फ़ंक्शन का उपयोग करने के लिए, आपको सुरक्षा नियमों के संस्करण 2 का चयन करना होगा , जिसे rules_version = '2';आपके सुरक्षा नियमों की पहली पंक्ति बनाकर किया जा सकता है :
rules_version = '2';
service firebase.storage {
match /b/{bucket}/o {
match /{allPaths=**} {मैं आगे के संदर्भ के लिए डॉक्स की जाँच करने की सलाह दूंगा ।
साथ ही, सेटअप 5 के अनुसार , इस स्क्रिप्ट की अनुमति नहीं है Node.jsक्योंकि require("firebase/app");यह firebase.storage()फ़ंक्शन के रूप में वापस नहीं आएगा । यह केवल उपयोग करके हासिल किया गया है import * as firebase from 'firebase/app';।
मार्च 2017 के बाद से: फायरबेस क्लाउड फ़ंक्शंस के अलावा , और Google क्लाउड के साथ फ़ायरबेस के गहन एकीकरण के साथ, यह अब संभव है।
क्लाउड फ़ंक्शंस के साथ आप क्लाउड स्टोरेज पर एपिक ऑपरेशन करने के लिए Google क्लाउड नोड पैकेज का उपयोग कर सकते हैं । नीचे एक उदाहरण है जो क्लाउड स्टोरेज से सभी फ़ाइल URL को एक सरणी में प्राप्त करता है। हर बार जब Google क्लाउड स्टोरेज में कुछ सहेजा जाता है तो यह फ़ंक्शन चालू हो जाएगा।
नोट 1 : यह एक बल्कि कम्प्यूटेशनल रूप से महंगा ऑपरेशन है, क्योंकि इसे एक बाल्टी / फ़ोल्डर में सभी फाइलों के माध्यम से साइकिल चलाना है।
नोट 2 : मैंने इसे सिर्फ एक उदाहरण के रूप में लिखा था, वादों में बहुत विस्तार किए बिना आदि। बस एक विचार देने के लिए।
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);
});
});
});
});
मुझे उम्मीद है कि यह आपको सामान्य विचार देगा। बेहतर क्लाउड फ़ंक्शंस उदाहरणों के लिए, फायरबेस के लिए Google के गीथब रेपो को क्लाउड फ़ंक्शंस के नमूनों से भरा देखें । इसके अलावा उनके Google क्लाउड नोड एपीआई दस्तावेज़ देखें
.thenइस तरह से चेन करना होगा:this.bucket .getFiles({ prefix: 'path/to/directory' }) .then((arr) => {})
चूंकि कोई भाषा सूचीबद्ध नहीं है, इसलिए मैं स्विफ्ट में इसका जवाब दूंगा। हम अत्यधिक डाउनलोड की सूचियों को पूरा करने के लिए Firebase Storage और Firebase Realtime Database का उपयोग करने की सलाह देते हैं:
साझा:
// 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]()
डालना:
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)
}
डाउनलोड:
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)
})
})
अधिक जानकारी के लिए, शून्य से ऐप देखें : फायरबेस के साथ विकसित करें , और यह कैसे करना है, के एक व्यावहारिक उदाहरण के लिए, यह स्रोत कोड से जुड़ा हुआ है ।
एक वर्कअराउंड एक फाइल (यानी लिस्ट.टैक्स) बनाने की हो सकती है, जिसमें कुछ भी न हो, इस फाइल में आप सभी फाइल के यूआरएल की सूची के साथ कस्टम मेटाडेटा (जो कि एक मैप <स्ट्रींग, स्ट्रिंग>) सेट कर सकते हैं।
इसलिए यदि आपको किसी फाइलर की सभी फाइलों को डाउनलाइड करने की आवश्यकता है, तो आप पहले list.txt फ़ाइल के मेटाडेटा को डाउनलोड करते हैं, फिर आप कस्टम डेटा के माध्यम से पुनरावृत्ति करते हैं और सभी फाइलों को मैप में URL के साथ डाउनलोड करते हैं।
मुझे भी इस समस्या का सामना करना पड़ा जब मैं अपने प्रोजेक्ट पर काम कर रहा था। मैं वास्तव में चाहता हूं कि वे एक अंतिम एपी विधि प्रदान करें। वैसे भी, मैंने ऐसा किया है: जब आप फायरबेस स्टोरेज में इमेज अपलोड कर रहे हों, तो एक ऑब्जेक्ट बनाएं और इस ऑब्जेक्ट को उसी समय फायरबेस डेटाबेस में पास करें। इस ऑब्जेक्ट में छवि का डाउनलोड URI शामिल है।
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);
}
});
बाद में जब आप किसी फ़ोल्डर से चित्र डाउनलोड करना चाहते हैं, तो आप बस उस फ़ोल्डर के तहत फ़ाइलों के माध्यम से पुनरावृति करते हैं। इस फ़ोल्डर का फायरबेस स्टोरेज में "फ़ोल्डर" के समान नाम है, लेकिन आप उन्हें नाम दे सकते हैं। मैंने उन्हें अलग धागे में डाल दिया।
@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) {
}
});
अब मेरे पास प्रत्येक छवि के लिए यूआरआई वाली वस्तुओं की एक सूची है, मैं जो कुछ भी करना चाहता हूं वह उनके साथ कर सकता हूं। उन्हें ImageView में लोड करने के लिए, मैंने एक और धागा बनाया।
@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;
}
यह बिटमैप की सूची लौटाता है, जब यह समाप्त होता है तो मैं उन्हें मुख्य गतिविधि में इमेज व्यू में संलग्न करता हूं। नीचे दिए गए तरीके @ ऑवरराइड हैं क्योंकि मेरे पास इंटरफेस हैं और अन्य थ्रेड्स में पूरा होने के लिए सुनते हैं।
@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);
}
}
ध्यान दें कि मुझे सूची चित्र के लिए पहले इंतजार करना होगा और फिर सूची बिटमैप पर काम करने के लिए थ्रेड को कॉल करना होगा। इस स्थिति में, छवि में 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);
}
उम्मीद है कि कोई इसे मददगार मिले। यह भविष्य में भी खुद के लिए एक गिल्ड की तरह काम करेगा।
हर अपलोड की गई छवि को ट्रैक करने और उसे डेटाबेस में संग्रहीत करने के लिए क्लाउड फंक्शन का उपयोग करके छवि को डेटाबेस में जोड़ने का एक और तरीका।
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
});
});
});
यहाँ पूर्ण कोड: https://gist.github.com/bossly/fb03686f2cb1699c2717a0359880cf84
नोड जेएस के लिए, मैंने इस कोड का उपयोग किया
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);
});
आप सूची से फ़ाइलों को फायरबेस स्टोरेज की सूची में सूचीबद्ध कर सकते हैं। इस पद्धति का उपयोग करने के लिए, फायरबेस भंडारण के इस संस्करण को लागू करना होगा। 'Com.google.firebase: firebase भंडारण: 18.1.1'
https://firebase.google.com/docs/storage/android/list-files
ध्यान रखें कि सुरक्षा नियमों को संस्करण 2 में अपग्रेड करें।
वास्तव में यह संभव है लेकिन केवल Firebase के बजाय Google क्लाउड एपीआई के साथ । ऐसा इसलिए है क्योंकि फायरबेस स्टोरेज एक Google क्लाउड स्टोरेज बकेट है जिसे Google क्लाउड एपीआई के साथ आसानी से पहुँचा जा सकता है, हालाँकि आपको फायरबेस के बजाय ऑथेंटिकेशन के लिए OAuth का उपयोग करना होगा।
मैंने उसी मुद्दे का सामना किया, मेरा और भी जटिल है।
व्यवस्थापक ऑडियो और पीडीएफ फाइलों को भंडारण में अपलोड करेगा:
ऑडियो / सीज़न 1, सीज़न 2 ... / क्लास 1, क्लास 2 / .mp3 फाइलें
किताबें / .pdf फाइलें
एंड्रॉइड ऐप को उप फ़ोल्डर और फ़ाइलों की सूची प्राप्त करने की आवश्यकता है।
समाधान स्टोरेज पर अपलोड ईवेंट को पकड़ रहा है और क्लाउड फ़ंक्शन का उपयोग करके फायरस्टार पर समान संरचना बनाता है।
चरण 1: मैन्युअल रूप से 'स्टोरेज' संग्रह और 'ऑडीओस / बुक्स' डॉक ऑन फायरस्टार बनाएं
चरण 2: सेटअप क्लाउड फ़ंक्शन
लगभग 15 मिनट लग सकते हैं: https://www.youtube.com/watch?v=DYfP-UIKxH0&list=PLl-K7zZEsYLkPZHe41m4jfAxUi0JjjgSM&index=1
चरण 3: क्लाउड फ़ंक्शन का उपयोग करके अपलोड ईवेंट को पकड़ो
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);
});
});
चरण 4: फायरस्टार का उपयोग करके एंड्रॉइड ऐप पर फ़ोल्डर्स / फ़ाइलों की सूची प्राप्त करें
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);
}
चरण 5: डाउनलोड यूआरएल प्राप्त करें
public static void downloadMediaFile(String path, OnCompleteListener<Uri> onCompleteListener) {
getStorage().getReference().child(path).getDownloadUrl().addOnCompleteListener(onCompleteListener);
}
ध्यान दें
हमें प्रत्येक आइटम के लिए "उप" संग्रह रखना होगा क्योंकि फायरस्टार संग्रह की सूची को पुनः प्राप्त करने का समर्थन नहीं करता है।
इस समाधान का पता लगाने में मुझे 3 दिन लगे, उम्मीद है कि आपको अधिकतम 3 घंटे लगेंगे।
चीयर्स।
विस्तार Rosário परेरा फर्नांडीस ' जवाब है, एक जावास्क्रिप्ट समाधान के लिए:
npm install -g firebase-tools
JavaScriptडिफ़ॉल्ट भाषा के रूप में सेट फ़ायरबाइट init पर npm install --save firebase
npm install @google-cloud/storage
npm install @google-cloud/firestore
... <any other dependency needed>
"firebase": "^6.3.3",
"@google-cloud/storage": "^3.0.3"
कार्य / package.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
}
listAllप्रकार्य बनाएं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;
}
firebase deployअपने क्लाउड फ़ंक्शन को अपलोड करने के लिए निष्पादित करेंbuild.gradle
dependencies {
...
implementation 'com.google.firebase:firebase-functions:18.1.0'
...
}
कोटलिन वर्ग
private val functions = FirebaseFunctions.getInstance()
val cloudFunction = functions.getHttpsCallable("getImages")
cloudFunction.call().addOnSuccessListener {...}
इस सुविधा के आगे विकास के बारे में, मैं कुछ समस्याओं में भाग गया, जो यहां मिल सकती हैं ।
जेएस के साथ ऐसा करने के लिए
आप उन्हें सीधे अपने div कंटेनर में जोड़ सकते हैं, या आप उन्हें एक सरणी में धकेल सकते हैं। नीचे आपको दिखाया गया है कि उन्हें अपनी डिव में कैसे जोड़ा जाए।
1) जब आप अपनी छवियों को स्टोरेज में स्टोर करते हैं, तो निम्न संरचना के साथ अपने फायरबेस डेटाबेस में छवि का संदर्भ बनाएं
/images/(imageName){
description: "" ,
imageSrc : (imageSource)
}
2) जब आप लोड करते हैं तो दस्तावेज़ आपके सभी छवि स्रोत URL को डेटाबेस से निम्न कोड के साथ भंडारण के बजाय खींचता है
$(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>");
})
})
});
आप निम्न कोड का उपयोग कर सकते हैं। यहाँ मैं इमेज को फायरबेस स्टोरेज में अपलोड कर रहा हूँ और फिर मैं फायर डाउनलोड डेटाबेस को फायरबेस डेटाबेस में डाउनलोड कर रहा हूँ।
//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) + "%...");
}
});
अब फायरबेस डेटाबेस में संग्रहीत सभी छवियों को लाने के लिए जिनका आप उपयोग कर सकते हैं
//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();
}
});
अधिक जानकारी के लिए आप मेरी पोस्ट Firebase Storage Example देख सकते हैं ।
इसलिए मेरे पास एक प्रोजेक्ट था जिसमें फायरबेस भंडारण से संपत्ति डाउनलोड करने की आवश्यकता थी, इसलिए मुझे इस समस्या को स्वयं हल करना पड़ा। यहां कैसे :
1- सबसे पहले, उदाहरण के लिए एक मॉडल डेटा बनाएं class Choice{}, उस वर्ग में एक स्ट्रिंग चर छवि नाम नाम को परिभाषित करता है ताकि यह ऐसा हो
class Choice {
.....
String imageName;
}
2- डेटाबेस / फायरबेस डेटाबेस से, ऑब्जेक्ट में इमेज के नाम को जाकर हार्डकोड करें, इसलिए यदि आपके पास Apple.png नाम का इमेज नाम है, तो ऑब्जेक्ट बनाएं
Choice myChoice = new Choice(...,....,"Apple.png");
3- अब, अपने फायरबेस स्टोरेज में एसेट्स के लिए लिंक प्राप्त करें जो कुछ इस तरह से होगा
gs://your-project-name.appspot.com/
4- आखिरकार, अपने फायरबेस स्टोरेज रेफरेंस को इनिशियलाइज़ करें और फाइल्स को लूप द्वारा प्राप्त करना शुरू करें
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- वही है
#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
मैं AngularFireसभी का उपयोग करने के लिए निम्नलिखित का उपयोग और उपयोग कर रहा हूंdownloadURL
getPhotos(id: string): Observable<string[]> {
const ref = this.storage.ref(`photos/${id}`)
return ref.listAll().pipe(switchMap(list => {
const calls: Promise<string>[] = [];
list.items.forEach(item => calls.push(item.getDownloadURL()))
return Promise.all(calls)
}));
}
एंड्रॉइड के लिए सबसे अच्छा प्रैटिस FirebaseUI और Glide का उपयोग करना है।
लायब्रेरी पाने के लिए आपको अपने gradle / ऐप पर इसे जोड़ना होगा। ध्यान दें कि इस पर पहले से ही ग्लाइड है!
implementation 'com.firebaseui:firebase-ui-storage:4.1.0'
और फिर अपने कोड उपयोग में
// 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);