Fundo

Um dos casos de uso que encontrei ao criar um aplicativo Android é lidar com UGC (conteúdo gerado pelo usuário), permitindo que os usuários do aplicativo carreguem seus ativos de seus telefones para um servidor em algum lugar.

Essa tarefa pode ser complicada e requer a construção de uma camada de rede básica, uma maneira de passar a carga útil, manipular a resposta e analisá-la quando a solicitação for bem-sucedida ou lidar com erros em caso de falha.

Há muitas maneiras de implementar uma solicitação de upload, como AsyncTask.
Há mais de uma maneira de fazer o mesmo e cada uma tem seus prós e contras.

Neste artigo, quero mostrar uma maneira diferente de fazer upload usando o Cloudinary SDK para fazer upload para sua nuvem Cloudinary, mesmo dentro do Cloudinary temos mais de uma maneira de fazer upload de um ativo para a nuvem.

Configurar

Antes de começarmos, precisamos fazer uma pequena configuração.
A primeira coisa é que precisamos registrar uma conta no Cloudinary .
Depois de se registrar para uma conta, precisamos obter nosso nome de nuvem no painel.

Assim que sua conta estiver configurada, passamos para o código.
A primeira coisa que precisamos fazer é inicializar o MediaManagerobjeto

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

Carregamento não assinado

Para fazer um upload básico precisamos chamar nosso MediaManager.get()objeto e depois a upload()função, a upload()função pega como parâmetro o payload que queremos enviar (pode ser Uri, InputStream, Stringe mais), fazemos um unsignedupload, ou seja, precisamos enviar um upload preset (explicação sobre upload preset em breve) e, finalmente, para fazer a chamada que estamos chamando dispatch().

Como resultado, temos um ID exclusivo para esta solicitação de upload.

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

Assim que terminarmos de criar a predefinição de upload , agora podemos colocá-la no unsigned()método.
Sim, é muito simples fazer upload de um ativo para sua nuvem, quando a imagem terminar seu processo de upload, podemos começar a experimentar as transformações!
As transformações são manipulações que podemos realizar em um ativo (imagem, vídeo, etc…) existem muitas transformações e se você quiser aprender mais do que os exemplos que mostro aqui, sugiro visitar a documentação do Cloudinary .

Se quisermos ter mais controle sobre nosso upload, podemos usar nossas funções de 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()— dispara quando o upload é iniciado.
• onProgress()- desencadeia quando obtemos mais progresso.
• onSuccess()— dispara quando o upload é concluído com sucesso.
• onError()— dispara quando ocorre um erro.
• onReschedule()— dispara quando o upload é reagendado.

Uploads assinados requerem uma assinatura, esta assinatura pode ser criada usando seu segredo de API do Cloudinary, MAS como estamos trabalhando no lado do cliente, você nunca deve expor seu segredo de API (ou qualquer informação sensível) dentro de seu aplicativo, em vez disso, você deve gerar um assinatura de autenticação em seu servidor.

Ao inicializar seu MediaManagerobjeto, você pode usar SignatureProvidersempre que estiver tentando fazer um upload assinado, o SDK do Android chamará, provideSignature()mas você deve concluir o seguinte antes, esse retorno de chamada executa um thread em segundo plano:

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

E se tivermos arquivos grandes (mais de 100 MB), como podemos carregá-los?
Dentro do SDK temos a opção de enviar arquivos grandes em chunks, podemos definir o tamanho do chunk dentro da chamada de função:

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

Há algumas coisas a serem observadas ao usar uploadLarge():

1. O tamanho do arquivo deve ser superior a 100 MB.
2. O tamanho do bloco padrão é 20 MB.
3. O tamanho mínimo do tamanho do bloco pode ser de 5 MB.

Um dos casos de uso ao fazer o upload pode ser que o usuário não queira esperar e minimize o aplicativo (mudando para outro aplicativo) ao lidar com esse cenário (geralmente com arquivos grandes) queremos criar um serviço que seja executado em segundo plano do nosso aplicativo , dentro do SDK criamos um serviço fácil chamadoListenerService

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

O SDK do Cloudinary torna o upload um processo fácil de implementar, temos alguns tipos de upload:

1. Unsigned — para uploads básicos.
2. Assinado — para uploads mais seguros.
3. Carregar grande — para arquivos grandes.
4. Também podemos registrar um serviço como retorno de chamada se o upload for executado quando o aplicativo estiver sendo executado em segundo plano.