Arrière-plan

L'un des cas d'utilisation que j'ai rencontrés lors de la création d'une application Android est la gestion de l'UGC (contenu généré par l'utilisateur), permettant aux utilisateurs de l'application de télécharger leurs ressources depuis leur téléphone vers un serveur quelque part.

Cette tâche peut être fastidieuse et nécessite la construction d'une couche réseau de base, un moyen de transmettre la charge utile, de gérer la réponse et de l'analyser lorsque la requête est acceptée ou de gérer les erreurs en cas d'échec.

Il existe de nombreuses façons d'implémenter une demande de téléchargement telle que AsyncTask.
Il y a plus d'une façon de faire la même chose et chacune a ses avantages et ses inconvénients.

Dans cet article, je veux montrer une autre façon de télécharger en utilisant le SDK Cloudinary pour télécharger sur votre cloud Cloudinary, même dans Cloudinary, nous avons plus d'une façon de télécharger un actif sur le cloud.

Installation

Avant de commencer, nous devons faire une petite configuration.
La première chose est que nous devons créer un compte chez Cloudinary .
Une fois que vous avez créé un compte, nous devons obtenir notre nom de cloud à partir du tableau de bord.

Une fois votre compte configuré, nous passons au code.
La première chose à faire est d'initialiser l' MediaManagerobjet

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

Téléchargement non signé

Pour effectuer un téléchargement de base, nous devons appeler notre MediaManager.get()objet, puis la upload()fonction, la upload()fonction obtient en paramètre la charge utile que nous voulons envoyer (cela peut être Uri, InputStream, Stringet plus), nous effectuons un unsignedtéléchargement, ce qui signifie que nous devons envoyer un télécharger le préréglage (explication sur le téléchargement du préréglage dans un instant) et enfin pour passer l'appel que nous appelons dispatch().

Par conséquent, nous avons un identifiant unique pour cette demande de téléchargement.

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

Une fois que nous avons fini de créer le préréglage de téléchargement , nous pouvons maintenant le mettre dans la unsigned()méthode.
Oui, c'est aussi simple que de télécharger une ressource sur votre cloud, lorsque l'image a terminé son processus de téléchargement, nous pouvons commencer à expérimenter les transformations !
Les transformations sont des manipulations que nous pouvons effectuer sur un asset (image, vidéo, etc…) il existe de nombreuses transformations et si vous voulez en savoir plus que les exemples que je montre ici je vous suggère de visiter la documentation de Cloudinary .

Si nous voulons avoir plus de contrôle sur notre téléchargement, nous pouvons utiliser nos fonctions de rappel :

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()— se déclenche au démarrage du téléchargement.
• onProgress()– se déclenche lorsque nous obtenons plus de progrès.
• onSuccess()— se déclenche lorsque le téléchargement se termine avec succès.
• onError()— se déclenche lorsqu'une erreur se produit.
• onReschedule()— se déclenche lorsque le téléchargement est replanifié.

Les téléchargements signés nécessitent une signature, cette signature peut être créée à l'aide de votre secret d'API Cloudinary, MAIS puisque nous travaillons côté client, vous ne devez jamais exposer votre secret d'API (ou toute information sensible) dans votre application, à la place, vous devez générer un signature d'authentification sur votre serveur.

Lorsque vous initialisez votre MediaManagerobjet, vous pouvez utiliser le SignatureProviderchaque fois que vous essayez d'effectuer un téléchargement signé, le SDK Android appellera, provideSignature()mais vous devez effectuer les opérations suivantes avant, ce rappel exécute un fil d'arrière-plan :

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

Et si nous avons des fichiers volumineux (plus de 100 Mo), comment pouvons-nous les télécharger ?
Dans le SDK, nous avons la possibilité d'envoyer de gros fichiers en morceaux, nous pouvons définir la taille du morceau dans l'appel de fonction :

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

Il y a quelques choses à remarquer lors de l'utilisation uploadLarge():

1. La taille du fichier doit être supérieure à 100 Mo.
2. La taille de bloc par défaut est de 20 Mo.
3. La taille minimale de la taille de bloc peut être de 5 Mo.

L'un des cas d'utilisation lors du téléchargement peut être que l'utilisateur ne veut pas attendre et minimise l'application (passage à une autre application) lors de la gestion de ce scénario (généralement avec des fichiers volumineux), nous voulons créer un service qui s'exécute en arrière-plan de notre application. , dans le SDK, nous créons un service facile appeléListenerService

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

Le SDK de Cloudinary fait du téléchargement un processus facile à mettre en œuvre. Nous avons quelques types de téléchargement :

1. Non signé — pour les téléchargements de base.
2. Signé — pour des téléchargements plus sécurisés.
3. Upload large — pour les fichiers volumineux.
4. Nous pouvons également enregistrer un service en tant que rappel si le téléchargement s'exécute lorsque l'application s'exécute en arrière-plan.