Durante la conferenza Google I / O del 2016, Firebase è stata reintrodotta nella comunità degli sviluppatori come strumento principale per fornire supporto rapido back-end per pagine Web e applicazioni mobili. Questo tutorial ti introdurrà alle funzionalità di archiviazione e recupero dei file disponibili per le tue app Android.
Per ulteriori informazioni sul database in tempo reale di Firebase, sulle analisi, sulla segnalazione degli arresti anomali e sull'autenticazione, consulta alcuni dei nostri altri tutorial qui su Envato Tuts+.
Per brevità, salteremo il processo di configurazione generale per Firebase nella tua app Android e nella console Firebase. Se è la prima volta che provi Firebase in un'app, ti suggerisco di consultare l'articolo di Ashraff Hathibelagal Guida introduttiva di Firebase per Android.
Prima di poter iniziare a utilizzare Firebase Storage, è necessario assicurarsi che l'utente sia autenticato o modificare le regole dei requisiti di autenticazione nella Firebase Console per consentire agli utenti non autenticati di accedere e caricare file. Per mantenere le cose semplici, faremo quest'ultimo. Iniziamo andando nella sezione Archiviazione di Firebase selezionando Conservazione nella colonna di navigazione a sinistra.
Successivamente, noterai che ci sono due schede nella parte superiore del Conservazione schermo: File e Regole.
Seleziona il Regole scheda e sulla linea consenti lettura, scrittura: if request.auth! = null;
, modificare !=
a ==
e fare clic su PUBBLICARE pulsante.
Ora qualsiasi utente della tua app dovrebbe essere in grado di caricare o scaricare file dal back-end di Firebase. Anche se questo non è l'ideale per un ambiente di produzione, renderà l'apprendimento di Firebase Storage molto più semplice senza dover scavare nel codice di autenticazione.
Mentre è possibile caricare file da un'app è fantastico, a volte si desidera semplicemente archiviare i file da qualche parte che possono essere facilmente accessibili e scaricati nella propria app. È qui che entra in gioco la possibilità di caricare manualmente i file dalla console di Firebase. Sotto il File scheda, vedrai un pulsante blu intitolato Caricare un file.
Fai clic e seleziona il file che desideri caricare e verrà visualizzato nella memoria di Firebase.
Selezionando quel file nella console verrà visualizzata una vista dettagliata, che consente di esaminare i file che sono stati precedentemente caricati.
Ora che hai un file archiviato in Firebase, andiamo avanti e lo riduciamo in un'app. Useremo un layout semplice nel nostro Attività principale
che contiene un ImageView
con un id
di immagine.
Per poter accedere ai tuoi file Storage di Firebase, devi prima ottenere un riferimento a FirebaseStorage
oggetto e quindi creare a StorageReference
all'URL del tuo progetto e il file che desideri scaricare. Puoi trovare l'URL del tuo progetto nella parte superiore del File sezione di Conservazione nella console di Firebase.
FirebaseStorage storage = FirebaseStorage.getInstance (); StorageReference storageRef = storage.getReferenceFromUrl ("gs: //tutsplus-firebase.appspot.com") .child ("android.jpg");
Successivamente, puoi creare un File
oggetto e tenta di caricare il file desiderato chiamando prendi il file
sul tuo StorageReference
con il nuovo File
oggetto passato come parametro. Poiché questa operazione avviene in modo asincrono, è possibile aggiungere un OnSuccessListener
e OnFailureListener
alla tua chiamata al fine di gestire qualsiasi contingenza.
try final File localFile = File.createTempFile ("images", "jpg"); storageRef.getFile (localFile) .addOnSuccessListener (new OnSuccessListener() @Override public void onSuccess (FileDownloadTask.TaskSnapshot taskSnapshot) Bitmap Bitmap = BitmapFactory.decodeFile (localFile.getAbsolutePath ()); mImageView.setImageBitmap (bitmap); ). addOnFailureListener (new OnFailureListener () @Override public void onFailure (@NonNull Exception exception) ); catch (IOException e)
Nel onSuccess ()
a partire dal OnSuccessListener
, puoi prendere il FileDownloadTask.TaskSnapshot
oggetto e recuperare il file, che è dove imposteremo l'immagine al nostro ImageView
.
Se hai solo bisogno di scaricare il file come byte[]
e non ne ha bisogno come file, che è il caso più probabile quando si carica un'immagine in un file ImageView
, quindi è possibile recuperare i byte in modo simile.
finale lungo ONE_MEGABYTE = 1024 * 1024; storageRef.getBytes (ONE_MEGABYTE) .addOnSuccessListener (new OnSuccessListener() @Override public void onSuccess (byte [] byte) Bitmap bitmap = BitmapFactory.decodeByteArray (byte, 0, bytes.length); mImageView.setImageBitmap (bitmap); );
Potrebbero esserci situazioni in cui non hai bisogno dei dati effettivi per un file memorizzato, ma preferirai l'URL. Puoi farlo in modo simile agli ultimi due esempi usando il getDownloadUrl ()
metodo sul tuo StorageReference
, che ti darà un Uri
indicando la posizione del file.
storageRef.getDownloadUrl (). addOnSuccessListener (new OnSuccessListener() @Override public void onSuccess (Uri uri) Log.e ("Tuts +", "uri:" + uri.toString ()); // Gestisci tutto ciò che hai intenzione di fare con l'URL qui);
Il metodo sopra riportato stamperà l'URL per l'immagine che abbiamo caricato manualmente in precedenza nel monitor Android.
E / Tuts +: uri: https://firebasestorage.googleapis.com/v0/b/tutsplus-firebase.appspot.com/o/android.jpg?alt=media&token=1828111c-78e7-4640-b418-c65e7571576a
Ora che sai come scaricare file da Firebase, è il momento di lavorare sui caricamenti. Come hai visto durante il download da Firebase Storage, i processi per ogni modulo dei tuoi dati sono abbastanza simili. Il caricamento non è diverso, quindi ci immergeremo semplicemente nel modo in cui puoi spostare i file dalla tua app in Firebase Storage.
Come per il download, è necessario ottenere un riferimento a FirebaseStorage
oggetto e creare un riferimento alla posizione di archiviazione del nuovo file come StorageReference
. Per questo esempio, mostreremo ic_launcher.png nel nostro ImageView
, e poi lo caricheremo come una matrice di byte.
FirebaseStorage storage = FirebaseStorage.getInstance (); StorageReference storageReference = storage.getReferenceFromUrl ("gs: //tutsplus-firebase.appspot.com") .child ("ic_launcher.png");
Successivamente, avremo bisogno di ottenere una matrice di byte dall'immagine salvata in memoria tramite il ImageView
. Questo viene fatto recuperandolo come a Bitmap
, comprimendolo in a ByteArrayOutputStream
, e poi trasformandolo in a byte[]
.
mImageView.setDrawingCacheEnabled (true); mImageView.measure (View.MeasureSpec.makeMeasureSpec (0, View.MeasureSpec.UNSPECIFIED), View.MeasureSpec.makeMeasureSpec (0, View.MeasureSpec.UNSPECIFIED)); mImageView.layout (0, 0, mImageView.getMeasuredWidth (), mImageView.getMeasuredHeight ()); mImageView.buildDrawingCache (); Bitmap bitmap = Bitmap.createBitmap (mImageView.getDrawingCache ()); ByteArrayOutputStream outputStream = new ByteArrayOutputStream (); bitmap.compress (Bitmap.CompressFormat.JPEG, 100, outputStream); byte [] data = outputStream.toByteArray ();
Finalmente, puoi creare un UploadTask
a chiamata putBytes (byte [])
per caricare la tua immagine su Firebase. Questo UploadTask
può anche avere un OnSuccessListener
e OnFailureListener
associato ad esso.
UploadTask uploadTask = storageReference.putBytes (dati); uploadTask.addOnFailureListener (new OnFailureListener () @Override public void onFailure (@NonNull Exception exception) ). addOnSuccessListener (new OnSuccessListener() @Override public void onSuccess (UploadTask.TaskSnapshot taskSnapshot) );
Quando controlli la pagina di archiviazione della console Firebase, dovresti vedere ic_launcher.png nella tua lista di file.
InputStream
o FileOra che sai come caricare un array di byte, gli altri due tipi di upload dovrebbero essere abbastanza intuitivi. Diciamo che abbiamo un file di testo chiamato test.txt nella nostra cartella delle risorse raw. Possiamo leggere questo in un InputStream
e quindi caricarlo utilizzando il putStream (InputStream)
metodo di StorageReference
.
FirebaseStorage storage = FirebaseStorage.getInstance (); StorageReference storageReference = storage.getReferenceFromUrl ("gs: //tutsplus-firebase.appspot.com") .child ("test.txt"); InputStream stream = getResources (). OpenRawResource (R.raw.test); UploadTask uploadTask = storageReference.putStream (stream);
Il caricamento di un file esistente è altrettanto semplice: è sufficiente ottenere un riferimento al file e chiamare PUTFILE (Uri)
con un URI che punta al tuo file. Per questo esempio, creeremo solo un file temporaneo vuoto nel nostro codice.
FirebaseStorage storage = FirebaseStorage.getInstance (); StorageReference storageReference = storage.getReferenceFromUrl ("gs: //tutsplus-firebase.appspot.com") .child ("test2.txt"); File file = null; prova file = File.createTempFile ("test2", "txt"); catch (IOException e) UploadTask uploadTask = storageReference.putFile (Uri.fromFile (file));
Sebbene i file che abbiamo caricato fino ad ora siano stati piccoli, ci possono essere periodi in cui si hanno caricamenti più grandi che richiedono una buona quantità di tempo. Firebase fornisce alcuni metodi con UploadTask
che ti consentirà di controllare il flusso di un caricamento e ascoltare i progressi e le modifiche dello stato. Questi metodi includono pausa()
, curriculum vitae()
, e Annulla()
. pausa()
e curriculum vitae()
ti permetterà di mettere in pausa e riprendere un UploadTask
, mentre Annulla()
lo fermerà completamente. Inoltre, puoi usare un OnPauseListener
e OnProgressListener
per tenere traccia degli stati di caricamento e di pausa.
mPause = (Button) findViewById (R.id.pause); mResume = (Button) findViewById (R.id.resume); mPause.setOnClickListener (new View.OnClickListener () @Override public void onClick (Visualizza vista) mUploadTask.pause ();); mResume.setOnClickListener (new View.OnClickListener () @Override public void onClick (Visualizza vista) mUploadTask.resume ();); FirebaseStorage storage = FirebaseStorage.getInstance (); StorageReference storageReference = storage.getReferenceFromUrl ("gs: //tutsplus-firebase.appspot.com") .child ("image.jpg"); InputStream stream = getResources (). OpenRawResource (R.raw.image); mUploadTask = storageReference.putStream (stream); mUploadTask.addOnPausedListener (new OnPausedListener() @Override public void onPaused (UploadTask.TaskSnapshot taskSnapshot) Log.e ("Tuts +", "upload in pausa!"); ); mUploadTask.addOnProgressListener (new OnProgressListener () @Override public void onProgress (UploadTask.TaskSnapshot taskSnapshot) Log.e ("Tuts +", "Byte caricati:" + taskSnapshot.getBytesTransferred ()); );
Il codice sopra ti permetterà di controllare il processo di caricamento per un'immagine piuttosto grande (1 MB, in questo caso) e vedere i suoi stati che cambiano nel log Android quando i pulsanti di pausa e ripresa vengono premuti.
E / Tuts +: byte caricati: 524288 E / Tuts +: caricamento in pausa! E / Tuts +: byte caricati: 786432
Come qualsiasi sviluppatore Android può attestare, a volte il ciclo di vita delle attività Android può causare problemi imprevisti. Una delle fonti più comuni di problemi sono gli ascoltatori che durano più a lungo dei loro genitori Attività
, che potrebbe essere il caso per gli ascoltatori di successo / fallimento collegati a un'attività di archiviazione di Firebase.
Se uno Attività
viene distrutto e ricreato (come nella rotazione dello schermo) mentre si sta svolgendo un'attività, si può finire con a NullPointerException
quando l'attività è stata completata. Per evitare ciò, vorrai salvare il tuo StorageReference
come un Stringa
nel tuo stato esterno impacchettare
nel onSaveInstanceState (Bundle)
metodo, quindi recuperarlo e aggiungere listener di successo a ciascuno FileDownloadTask
o FileUploadTask
associato a questo StorageReference
.
@Override protected void onSaveInstanceState (Bundle outState) super.onSaveInstanceState (outState); if (mStorageReference! = null) outState.putString (EXTRA_STORAGE_REFERENCE_KEY, mStorageReference.toString ()); @Override protected void onRestoreInstanceState (Bundle savedInstanceState) super.onRestoreInstanceState (savedInstanceState); final String stringRef = savedInstanceState.getString (EXTRA_STORAGE_REFERENCE_KEY); if (stringRef == null) return; mStorageReference = FirebaseStorage.getInstance (). getReferenceFromUrl (stringRef); Elencotasks = mStorageReference.getActiveDownloadTasks (); for (Attività FileDownloadTask: tasks) task.addOnSuccessListener (this, new OnSuccessListener () @Override public void onSuccess (FileDownloadTask.TaskSnapshot taskSnapshot) Log.e ("Tuts +", "download riuscito!"); );
In questo tutorial hai appreso molto su Firebase e le sue opzioni disponibili per l'archiviazione dei file. Ora dovresti essere in grado di caricare e scaricare file, controllare i trasferimenti di dati e gestire le modifiche nel ciclo di vita delle attività della tua app mentre si sta verificando una transazione.
Mentre abbiamo appena scalfito la superficie di ciò che puoi fare in Firebase, la comprensione di questo strumento ti consentirà di ampliare le funzionalità delle tue app e offrire esperienze straordinarie per i tuoi utenti.
E nel frattempo, dai uno sguardo ad alcuni dei nostri articoli sullo sviluppo di Android!