Android e OpenAI: integrando DALL-E, Whisper e GPT para áudios e imagens.

Gerando a primeira informação - Apresentação

Se tem interesse em utilizar inteligência artificial generativa em seus aplicativos Android para gerar imagens, resumos, transcrições e áudios, fique neste curso para aprender.

Meu nome é Júnior Martins e serei seu instrutor.

Audiodescrição: Júnior é um homem de pele clara, com cabelos escuros, compridos e amarrados em um rabo de cavalo baixo. Ele usa óculos arredondado com armação preta e uma camisa preta. No fundo há uma parede lisa iluminada por LEDs em um degradê de azul para o rosa.

O que aprenderemos

Durante este curso, utilizaremos o aplicativo AnotaAI. Este é um aplicativo de notas que permite adicionar, além de itens de texto, imagens e áudios.

Nosso objetivo será fazer com que este aplicativo consiga resumir alguns conteúdos quando precisarmos realizar transcrições. Podemos, por exemplo, abrir um áudio e, na faixa do áudio, ter um botão de "Transcrever áudio". Ao clicarmos, fazemos uma solicitação e o áudio aparece transcrito.

Outra opção que podemos implementar é a "Resumir e ouvir". Em uma nota com vários áudios, podemos clicar em um botão que escuta todos os áudios e cria um resumo, tanto em formato de áudio, com diferentes vozes, como em texto, com o conteúdo do áudio transcrito.

Também podemos implementar uma função "Gerar capa", utilizando a API Dall-E para converter todo o conteúdo da nota em uma única imagem. Clicando nessa funcionalidade, após um tempo de carregamento, obtemos uma imagem na nota, representando o conteúdo do áudio. A imagem gerada dá a entender os áudios são um material de ensino, porque apresenta uma lista de itens a ser feito, cadernos, lápis e outros materiais de papelaria para estudo.

Observação: As APIs que utilizaremos, tanto a Dall-E, para imagens, quanto o Whisper, para o áudio, usa o modelo do GPT.

Vantagens do curso

É importante ter todo esse conteúdo para que suas aplicações no mundo real ofereçam experiências mais ricas para as pessoas usuárias. Está cada vez mais comum que as empresas desejem que as aplicações utilizem IA para melhorar a vida da pessoa usuária final.

Neste curso, aprenderemos como gerar resumos, criar imagens de capa e, principalmente, aprenderemos os conceitos para conseguirmos realizar tudo isso. Assim você poderá aplicar esse conhecimento em diferentes casos de uso.

Para seguir seus estudos, recomendamos que tenha alguns pré-requisitos:

• Bom conhecimento do *gerenciamento de estados com Jetpack Compose
• Entendimento sobre o sistema de dependências;
• Conhecimento sobre sistema de arquivos do Android.

Teremos explicações sobre esses pontos, mas se não forem uma novidade para você, terá uma compreensão maior do conteúdo.

Esperamos que esteja com animação para começar.

Vamos lá!

Gerando a primeira informação - Conhecendo o projeto

Antes de prosseguirmos com o nosso conteúdo, reservei este momento para conhecermos um pouco mais do projeto e iniciarmos um ponto importante do aprendizado com as APIs da OpenAI. Após a instalação e abertura do projeto no Android Studio, recomendamos que observe alguns pontos principais para se familiarizar com a estrutura.

Navegando pelo projeto

Lembretes iniciais: O projeto é todo feito em Jetpack Compose e utiliza conceitos como injeção de dependências.

Dentro da pasta "di.module", temos o DatabaseModule.kt e o FileUtilsModule.kt. O FileUtilsModule é uma classe responsável por instanciar a injeção de dependências da classe FileUtils.

Clicando em FileUtils e pressionando "Ctrl + B", descobrimos que essa classe está em "media > FileUtils.kt". Essa classe lida com a parte de armazenamento, ou seja, salva algumas informações no armazenamento do Android. Não focaremos muito em seu funcionamento, mas há material explicativo sobre ela, a injeção de dependência e outros pontos nas atividades.

Além disso, na pasta "Network", temos o arquivo com a classe DownloadServices. Já abordamos sobre o funcionamento dela em outro curso, mas, basicamente, seu objetivo é, através de uma URL qualquer, fazer o download do conteúdo para salvá-lo no Android. Utilizaremos essa classe em alguns momentos.

Dentro da pasta "ui" temos outra estrutura de pastas relacionadas à Interface de Usuário (UI), bastante familiar. Temos as pastas:

• camera
• components
• home
• listNotes
• navigation
• notes
• settings
• theme
• utils

Utilizaremos muito essas pastas, principalmente a "home" e a "listNotes". Na pasta "home", trabalharemos bastante no HomeScreen.kt e no HomeViewModel.kt. Inclusive, no HomeViewModel.kt temos a injeção das dependências downloadServices e fileUtils. Quando chegar o momento de utilizá-las, explicarei melhor. Na "listNotes", trabalharemos com o ListNotesViewModel.kt.

A pasta "navigation" tem uma estrutura de navegação Compose. Por fim, a pasta "utils" contem o AppAplicaton.kt e o MainActivity.kt, sendo que a MainActivity foi criada para lidarmos principalmente com gravação e reprodução de áudio, destacando que a utilizaremos para alguns testes.

Detalhes do projeto

Este projeto possui um diferencial em relação a outros que já apresentamos. Dentro do "Gradel Scripts", temos o build.gradle.kts, tanto no módulo "app", quanto no aplicativo. Nesse arquivo há um plugin aplicado: libs.plugin.google.secrets.gradle.plugin, que está na última linha.

Arqivo libs.plugin.google.secrets.gradle.plugin

plugins { this: PluginDependenciesSpecScope
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.android) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.hilt) apply false
    alias(libs.plugins.ksp) apply false
    alias(libs.plugins.google.secrets.gradle.plugin) apply false
}

Esse plugin nos permite lidar com o armazenamento de chaves de API de maneira segura. Mas lembre-se, para utilizar essas APIs OpenAI, precisamos abrir o dashboard e acessar a página de API Keys da OpenAI, para criar uma API customizada.

Criando uma API Key customizada

Vou te ensinar como fazer isso, mas é extremamente importante não compartilharmos essa chave com outras pessoas ou enviá-la para o repositório. Cada pessoa deve guardá-la localmente, por exemplo, como uma variável de ambiente, ou utilizando a ferramenta secrets-gradle-plugin, da Google.

Observação: Essa ferramenta, como o nome diz, é um plugin. Você pode acessar o código do secrets-gradle-plugin no GitHub.

Após instalar e configurar o plugin, podemos retornar ao projeto, no Android Studio, e acessar o arquivo local.properties. Esse é um arquivo que o Android Studio gera quando você instalar o projeto, e tem uma aparência similar a esta:

Arquivo local.properties

## This file must *NOT* be checked into Version Control Systems,
## as it contains information specific to your local configuration.
#
# Location of the SDK. This is only used by Gradle.
# For customization when using a Version Control System, please read the
# header note.
#
#Mon Oct 28 15:35:04 BRT 2024
sdk.dir=E\:\\AndroidStudio\\AppData\\Local\\Android\\Sdk

Dica: Nas atividades, você encontra instruções de como instalar esse plugin, mas você também pode procurá-las nas documentações da Google.

O arquivo tem comentários no começo e, por exemplo, um sdk.dir, que indica onde está o Android Studio. Graças a esse plugin, podemos adicionar variáveis extras e as acessar no código. Já temos uma variável declarada por padrão e, se declararmos outra, como OPENAI-KEY, qualquer coisa que escrevermos depois do =, o plugin nos permitirá acessá-la no arquivo posteriormente.

Nosso objetivo é colocar a API que geraremos no navegador, com a ferramenta da OpenAI, dentro do nosso projeto. A página "API keys" da OpenAI é um teste da OpenAI, que permite acessar toda a parte de API, consumo, limite e outros aspectos dos projetos.

É importante saber que, para acessar esses recursos de geração da API, são necessários créditos. Contudo, para obtermos a chave API, basta clicarmos no botão em "Create new secret key" (Criar nova chave secreta), no centro da página. Com isso, abrimos uma janela flutuante com o formulário "Create new secret key".

Nesse formulário, recebemos a sugestão de adicionar um nome específico (Name) para a chave, mas é opcional. O outro campo é para escolhermos o projeto (Project), já preenchido com um "Project", que é um projeto padrão, e podemos mantê-lo.

Também temos o campo de permissões (Permissions), com as opções all (todas), restricted (restrita) e read only (apenas leitura). O "All" está selecionado e manteremos assim, então podemos apenas clicar no botão "create secret key", no canto inferior direito da janela.

Recaptulação: Na página da API keys, ao clicar no botão "Create new secret key", abrimos um formulário que já vem com todos os campos importantes preenchidos por padrão.

Se quisermos, podemos adicionar um nome para a chave, mas é opcional. Se não, podemos apenas clicar no botão "Create new secret key", no canto infeior direito do formulário.

Com isso, é gerada uma sequência de caracteres, que formam nossa chave. A janela "Save your key" (Salve sua chave) aparece no centro da tela com esses caracteres, e podemos clicar no botão "Copy" (Copiar) para copiarmos a chave (hash).

Adicionando a chave ao projeto

De volta ao Android Studio, no arquivo local.properties, salvaremos essa chave dentro da OPENAI-KEY. Agora podemos acessar isso em outros pontos do código.

Arquivo local.properties

## This file must *NOT* be checked into Version Control Systems,
## as it contains information specific to your local configuration.
#
# Location of the SDK. This is only used by Gradle.
# For customization when using a Version Control System, please read the
# header note.
#
#Mon Oct 28 15:35:04 BRT 2024
sdk.dir=E\:\\AndroidStudio\\AppData\\Local\\Android\\Sdk
OPENAI-KEY=chave-gerada

Após adicionarmos a chave ao projeto, é importante fecharmos a janela "Save your key", que mostra nossa chave. Apesar dessa chave ficar listada na página de API keys da OpenAI, esse é o único momento em que você pode copiá-la

Observação: A chave mostrada no vídeo é única para a conta utilizada durante este curso. Posteriormente ela será expirada. Contudo, sempre recomendamos que não compartilhem essa chave com ninguém.

Explorando o painel da OpenAI

Após obtermos a chave e utilizá-la, podemos acessar o menu lateral esquerdo do painel. Dentre as opções, encontramos a seção "Limits" (Limites), onde estão listados todos os modelos disponíveis, com uma contagem aproximada dos custos de uso e de tokens.

Também temos a seção "Usage" (Usos), onde acessamos os custo e gastos conforme utilizamos a API. Como dito, precisamos adicionar créditos para começarmos a utilizar essas APIs, e isso é analisado dentro da seção "Usage", no campo "Credit Grants", do lado direito. Também é nessa seção que você adiciona créditos, clicando no botão "Increase limit" (Aumentar limite).

Algumas contas ainda têm créditos gratuitos, da época em que criar uma conta na OpenAI dava alguns créditos. Talvez este seja o seu caso, senão será necessário adicionar créditos. Se você estiver utilizando uma API da empresa, é necessário realizar esta consulta.

Nosso papel aqui no curso é te apresentar o painel dessas seções para você saber como analisar o consumo dos modelos e os créditos disponíveis. A partir desses créditos, conseguiremos acessar os recursos dessa API.

Recomendamos que explore melhor o projeto e o dashboard da OpenAI.

Nosso projeto está pronto para começarmos as implementações e faremos isso a seguir.

Gerando a primeira informação - Gerando API Key

Para utilizarmos o acesso da OpenAI e suas APIs no Android, utilizaremos a biblioteca openai-kotlin. Esta biblioteca, como o próprio nome sugere, fornece acesso às APIs da OpenAI e é compatível com Kotlin, como no nosso projeto Android.

Conhecendo a biblioteca openai-kotlin

Podemos explorar mais sobre essa API acessando o repositório oficial da openai-kotlin. No README desse projeto, podemos acessar a seção "Setup" (Configuração), que ensina como instalá-la, de duas maneiras.

A primeira maneira é a instalação direta da biblioteca, útil em projetos mais robustos, com outras dependências já configuradas, especialmente no que diz respeito ao motor do Ktor (Ktor's engines), utilizado para completar as requisições de forma mais eficiente.

Nosso projeto está mais básico no momento e, para uma gestão de dependências mais automática, optaremos pelo segundo método de instalação, que utiliza o BOM (Bill of Materials). Isso nos permite configurar a biblioteca sem nos preocuparmos tanto com dependências e versões.

Adicionando a biblioteca ao projeto

Para isso, copiaremos o código dentro de dependencies{}:

dependencies {
    // import Kotlin API client BOM
    implementation platform('com.aallam.openai:openai-client-bom:3.8.2')

    // define dependencies without versions
    implementation 'com.aallam.openai:openai-client'
    runtimeOnly 'io.ktor:ktor-client-okhttp'
}

Em seguida, de volta ao nosso projeto dentro do Android Studio, acessaremos o arquivo build.gradle.kts. No final desse arquivo, após ksp.libs.androidx, pressionaremos "Enter" duas vezes e colaremos o código copiado.

Arquivo build.gradle.kts

// código omitido

// Room
implementation(libs.androidx.room.runtime)
implementation(libs.androidx.room.ktx)
annotationProcessor(libs.androidx.room.compiler)
ksp(libs.androidx.room.compiler)

// import Kotlin API client BOM
implementation platform('com.aallam.openai:openai-client-bom:3.8.2')

// define dependencies without versions
implementation 'com.aallam.openai:openai-client'
runtimeOnly 'io.ktor:ktor-client-okhttp'

Precisaremos fazer alguns ajustes. Se o seu projeto, como o deste curso, já estiver utilizando a versão mais atualizada de gerenciamento de dependências, o Catalogue, também será necessário fazer alterações nele.

Na importação do Kotlin API client BOM, substituiremos as aspas simples, dentro dos parênteses, por aspas duplas, no Implementation platform(). Também deixaremos o plataform() entre parênteses.

// import Kotlin API client BOM
implementation (platform("com.aallam.openai:openai-client-bom:3.8.2"))

Na definição de dependências sem versões (define dependencies without versions), também trocamos as aspas simples por duplas, e deixamos a informações entre parênteses.

// import Kotlin API client BOM
implementation (platform("com.aallam.openai:openai-client-bom:3.8.2"))

// define dependencies without versions
implementation ("com.aallam.openai:openai-client")
runtimeOnly ("io.ktor:ktor-client-okhttp")

Após isso, podemos passar o mouse sobre essas dependências, que estão com uma marcação amarela e, clicar em "Replace with New Library Catalogue". Outra forma de fazer isso é clicarmos na dependência com o alerta em amarelo, pressionarmos "Alt + Enter" e selecionarmos essa mesma opção.

// import Kotlin API client BOM
implementation (platform(libs.openai.client.bom))

// define dependencies without versions
implementation (libs.openai.client)
runtimeOnly (libs.ktor.client.okhttp)

Uma observação, precisamos configurar essa dependência como um BOM, na importação do Kotlin API client BOM, ele não fez a substituição completa, então precisamos adicionar o (plataform()), colocando a biblioteca dentro dos parênteses de plataform(). Caso contrário, a biblioteca parecerá instalada, mas não funcionará.

// import Kotlin API client BOM
implementation (platform(libs.openai.client.bom))

Feito isso, clicamos em "Sync Now", na parte superior direita e aguardamos o resultado.

Audiodescrição: Tela de carregamento. Uma barra escrito "carregando..." é preenchida de amarelo sobre um fundo azul escuro. Enquanto isso, tocam sons de circuitos.

Testando a disponibilidade das bibliotecas instaladas

Após a instalação das bibliotecas, verificaremos se elas estão disponíveis no projeto. Para isso, acessamos "utils > MainActivity.kt.

Realizaremos alguns testes para verificar se a biblioteca funciona e se está acessando as APIs necessárias. Recomendo fazer isso diretamente na MainActivity, porque ela é a primeira tela a ser executada, testando tudo automaticamente.

Na seção "Getting Started", na documentação da openai-kotlin, logo após a parte de instalação, encontramos as configurações de instância. Descobrimos que podemos passar a API Key, definir um timeout (tempo de espera) e outras configurações extras, dependendo da situação. Essas, porém, são configurações mais avançadas.

No nosso caso, podemos voltar para a MainActivity projeto e apenas criar uma variável chamada val openAI, que receberá a OpenAI. Ao digitarmos "OpenAI", o Android Studio sugere importarmos as dependências da biblioteca, indicando que ela está disponível. Faremos essa importação, escreveremos os parênteses e, dentro deles, passaremos uma string comum.

Arquivo MainActivity.kt

import com.aallam.openai.client.OpenAI

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    private var recorder: MediaRecorder? = null
    private var player: MediaPlayer? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val openAI = OpenAI("")

// código omitido

Com isso, o código já entende que se trata da chave de API, o nosso token. Na linha abaixo, escreveremos openAI.. Com isso, podemos acessar várias funcionalidades como:

• Chat
• Downloads
• Deleção
• Geração de imagens
• Entre outras

Dica: Estudaremos muitas dessas funcionalidades ao longo do curso.

Para acessarmos tudo isso, precisamos passar a API Key. Poderíamos copiar o hash que salvamos no local.properties, mas não é a forma correta. A maneira apropriada de acessarmos essa chave é utilizando o plugin, que já conhecemos.

No lugar da string vazia, chamaremos BuildConfig., e encontraremos na lista sugerida pelo Android Studio, o OPENAIKEY. Selecionaremos ele.

val openAI = OpenAI(BuildConfig.OPENAIKEY)

Ao clicarmos em OPENAIKEY e pressionarmos "Ctrl + B", abrimos o BuildConfig.java, um arquivo gerado automaticamente pelo projeto. Caso não apareça, talvez seja necessário clicar no botão "Make Module", que tem um ícone de um martelo com um quadrado, no canto superior direito. Essa opção fará um rebuild do projeto.

O arquivo BuildConfig.java é gerado conforme executamos o projeto. Se a opção OPENAIKEY não aparecer de imediato, significa que ele não foi gerado. Ao executarmos o rebuild do projeto a máquina acessará a configuração correta da sua chave, e não a chave de outra pessoa.

Para testar se a API está funcionando, precisaremos de mais alguns passos, que faremos a seguir.

Sobre o curso Android e OpenAI: integrando DALL-E, Whisper e GPT para áudios e imagens.

O curso Android e OpenAI: integrando DALL-E, Whisper e GPT para áudios e imagens. possui 125 minutos de vídeos, em um total de 41 atividades. Gostou? Conheça nossos outros cursos de IA para Mobile em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Gerando a primeira informação
• Transcrevendo áudios com Whisper
• Gerando imagens com Dall-E
• Resumindo textos e gerando áudios
• Melhorando a arquitetura do projeto