Sfondo

Uno dei casi d'uso in cui mi sono imbattuto durante la creazione di un'applicazione Android è la gestione di UGC (contenuto generato dall'utente), che consente agli utenti dell'applicazione di caricare le proprie risorse dal proprio telefono su un server da qualche parte.

Questa attività può essere ingombrante e richiede la creazione di un livello di rete di base, un modo per passare il payload, gestire la risposta e analizzarla quando la richiesta ha successo o la gestione degli errori in caso di errore.

Esistono molti modi per implementare una richiesta di caricamento come AsyncTask.
C'è più di un modo per fare lo stesso e ognuno ha i suoi pro e contro.

In questo articolo, voglio mostrare un modo diverso di caricare utilizzando Cloudinary SDK per caricare sul tuo cloud Cloudinary, anche all'interno di Cloudinary abbiamo più di un modo per caricare una risorsa nel cloud.

Impostare

Prima di iniziare dobbiamo fare un piccolo setup.
La prima cosa è che dobbiamo registrarci per un account su Cloudinary .
Una volta registrato per un account, dobbiamo ottenere il nome del nostro cloud dalla dashboard.

Una volta impostato il tuo account, passiamo al codice.
La prima cosa che dobbiamo fare è inizializzare l' MediaManageroggetto

Map config = new HashMap();
config.put("cloud_name", "myCloudName");
MediaManager.init(this, config);

Caricamento non firmato

Per fare un upload di base dobbiamo chiamare il nostro MediaManager.get()oggetto e poi la upload()funzione, la upload()funzione ottiene come parametro il payload che vogliamo inviare (può essere Uri, InputStream, Stringe altro), facciamo un unsignedupload, il che significa che dobbiamo inviare un upload preset (spiegazione su upload preset in un po ') e infine per effettuare la chiamata che stiamo chiamando dispatch().

Di conseguenza, abbiamo un ID univoco per questa richiesta di caricamento.

String requestId = MediaManager.get().upload(imageFile).unsigned("sample_preset").dispatch();

Una volta terminata la creazione del preset di caricamento , ora possiamo inserirlo nel unsigned()metodo.
Sì, è così semplice caricare una risorsa sul tuo cloud, quando l'immagine ha terminato il processo di caricamento possiamo iniziare a sperimentare le trasformazioni!
Le trasformazioni sono manipolazioni che possiamo eseguire su un asset (immagine, video, ecc...) ci sono molte trasformazioni e se vuoi saperne di più rispetto agli esempi che mostro qui ti suggerisco di visitare la documentazione di Cloudinary .

Se vogliamo avere più controllo sul nostro caricamento possiamo utilizzare le nostre funzioni di callback:

MediaManager.get()
 .upload(fileToUpload)
 .unsigned(“sample_preset”)
 .options(options)
 .callback(new UploadCallback() {
 @Override
 public void onStart(String requestId) {
 // Called when upload starts
 }

@Override
 public void onProgress(String requestId, long bytes, long totalBytes) {
 // Called when progress is made
 }

@Override
 public void onSuccess(String requestId, Map resultData) {
 // Called on success
 }

@Override
 public void onError(String requestId, ErrorInfo error) {
 // Called on error
 }

@Override
 public void onReschedule(String requestId, ErrorInfo error) {
 // Called when upload is rescheduled 
 }
 }).dispatch();Signed Upload

• onStart()— si attiva all'avvio del caricamento.
• onProgress()- si attiva quando otteniamo ulteriori progressi.
• onSuccess()—si attiva quando il caricamento termina correttamente.
• onError()—si attiva quando si verifica un errore.
• onReschedule()—si attiva quando il caricamento viene ripianificato.

I caricamenti firmati richiedono una firma, questa firma può essere creata utilizzando il tuo segreto API Cloudinary, MA poiché stiamo lavorando su un lato client non dovresti mai esporre il tuo segreto API (o qualsiasi informazione sensibile) all'interno della tua applicazione, invece, dovresti generare un firma di autenticazione sul tuo server.

Quando inizializzi il tuo MediaManageroggetto, puoi utilizzare SignatureProviderogni volta che provi a effettuare un caricamento firmato, l'SDK Android chiamerà provideSignature()ma dovresti completare quanto segue prima, questo callback esegue un thread in background:

MediaManager.init(this, new SignatureProvider() {
   @Override
   public Signature provideSignature(Map options) {
       // call server signature endpoint
   }
}, null);

Cosa succede se abbiamo file di grandi dimensioni (oltre 100 MB) come possiamo caricarli?
All'interno dell'SDK abbiamo la possibilità di inviare file di grandi dimensioni in blocchi, possiamo impostare la dimensione del blocco all'interno della chiamata di funzione:

cloudinary.uploader().uploadLarge(temp, ObjectUtils.asMap("upload_preset", "sample_preset","resource_type", "video", "chunk_size", 5243000))

Ci sono alcune cose da notare quando si utilizza uploadLarge():

1. La dimensione del file deve essere superiore a 100 MB.
2. La dimensione predefinita del blocco è 20 MB.
3. La dimensione minima della dimensione del blocco può essere di 5 MB.

Uno dei casi d'uso durante il caricamento può essere che l'utente non vuole aspettare e riduce a icona l'app (passando a un'altra app) quando gestisce questo scenario (di solito con file di grandi dimensioni) vogliamo creare un servizio, che viene eseguito in background della nostra applicazione , all'interno dell'SDK creiamo un semplice servizio chiamatoListenerService

public class UploadListner extends ListnerService {
  @Override
  public void onStart(String requestId) {
    // Called when upload starts.
  }
  @Override
  public void onProgress(String requestId, long bytes, long totalBytes) {
    // Called when upload makes progress.
  }
  @Override
  public void onSuccess(String requestId, Map resultData) {
     // Called when upload finishes successfully.
  }
  @Override
  public void onError(String requestId, ErrorInfo error) {
     // Called on error
  }
  @Override
  public void onReschedule(String requestId, ErrorInfo error) {
    // Called when upload is rescheduled.
  }
}

<application
  ...
  <service 
    android:name="com.myapp.UploadListner" />
  <meta-data
    android:name="cloudinaryCallbackService"
    android:value="com.myapp.UploadListner" />
  ...
</application>

MediaManager.get().upload(fileToUpload).unsigned("sample_preset").callback(new UploadListener());

L'SDK di Cloudinary rende il caricamento un processo facile da implementare, abbiamo alcuni tipi di caricamento:

1. Unsigned: per caricamenti di base.
2. Firmato: per caricamenti più sicuri.
3. Carica grande: per file di grandi dimensioni.
4. Possiamo anche registrare un servizio come callback se il caricamento viene eseguito quando l'app è in esecuzione in background.