1⃣ Adapter

💡 Conceito

O Adapter é o “meio-campo” entre os dados (lista, array, resultado do banco/API) e o

componente visual (RecyclerView, ListView, Spinner).
Ele pega cada item da lista e monta o layout correspondente na tela.

🛠 Como implementar (passo a passo)

De na o que você vai listar

Ex: lista de alunos, produtos, posts…

Crie uma classe de modelo (por exemplo, Aluno com nome, idade, etc).

Crie o layout de cada item

Arquivo em res/layout/ (ex: item_aluno.xml).

Nesse layout vão os TextView, ImageView etc. de UM item da lista.

Crie a classe Adapter

Classe em Kotlin que recebe a lista de dados e, às vezes, um listener de clique.

Dentro dela você:

Cria uma classe interna ViewHolder que guarda as referências dos componentes do
item_aluno.xml.

Implementa o método que cria o layout do item (in a o XML e cria o ViewHolder).

Implementa o método que preenche os dados no layout (pega o objeto da posição X e joga nos
TextViews).

Implementa o método que informa o tamanho da lista.

Conecte o Adapter com o componente visual

Na Activity ou Fragment:

Pegue a referência do RecyclerView/ListView.

De na um LayoutManager (no caso do RecyclerView).

Crie uma instância do Adapter passando a lista de dados.

Atribua o adapter ao RecyclerView/ListView.

Atualizar dados

Quando a lista mudar, atualize a lista dentro do Adapter e chame o método para avisar que os
dados mudaram (ex: notifyDataSetChanged ou equivalente).

👉 Pra prova:

“Adapter é o responsável por transformar cada item de uma coleção de dados em um item visual
em componentes como RecyclerView ou ListView, in ando o layout e preenchendo os campos.”
fi
fi
fl
fl
 2⃣ Métodos de ciclo de vida das Activitys
💡 Conceito

Uma Activity tem momentos bem de nidos da sua “vida”: criação, exibição, pausa, parada e
destruição. Cada momento tem um método especí co onde você coloca o código certo.

🛠 Como implementar na prática

Vou te dizer o que colocar em cada método:

onCreate() – criação da tela

Chamado uma vez quando a Activity é criada.

O que você faz aqui:

De ne o layout da tela (setContentView).

Liga variáveis do Kotlin/Java aos componentes do XML ( ndViewById ou ViewBinding).

Con gura Adapter de listas, listeners de botão, inicializa ViewModel, Room etc.

Pense como: “montar tudo que a tela precisa para existir”.

onStart() – Activity está prestes a car visível

Tela está “quase” aparecendo.

Lugar para:

Começar a observar dados que serão mostrados.

Registrar alguns listeners que dependem da tela visível (por exemplo, algum BroadcastReceiver
simples).

onResume() – Activity está em primeiro plano

Aqui a tela está ativa e o usuário está interagindo.

Use para:

Retomar animações.

Retomar leitura de sensores (GPS, acelerômetro).

Retomar câmera, streams etc.

onPause() – outra Activity vem por cima

Momento de: “opa, talvez o usuário vá sair da tela”.

Use para:

Salvar rapidamente algo temporário (texto de formulário, posição de scroll).

Pausar animações, vídeos, música.

Persistir pequenas coisas em SharedPreferences.

fi
fi
fi
fi
fi
fi
onStop() – Activity não está mais visível

A tela saiu do foco e não aparece mais.

Use para:

Desregistrar listeners mais pesados.

Parar atualizações que não precisam rodar “escondidas”.

Fechar conexões que não fazem sentido sem a tela.

onDestroy() – Activity encerrada

O Android chamou quando a Activity será destruída.

Use para:

Liberar recursos que você criou manualmente (threads, handlers, tarefas muito especí cas).

Nem sempre é chamado (se o sistema matar o processo).

onRestart() – usuário voltou para a Activity

Chamado quando a Activity estava parada (onStop) e volta a ser usada.

Use para:

Recarregar dados do servidor/banco se necessário.

Atualizar a interface com algo novo.

👉 Pra prova, responda algo assim:

“Uso onCreate() para con gurar a interface e inicializar componentes; onStart() e onResume() para
deixar a tela pronta e ativa; onPause() e onStop() para pausar e salvar; onDestroy() para liberar
recursos; onRestart() quando a Activity volta a ser usada depois de parada.”

3⃣ Intents
💡 Conceito

Intent = “intenção de fazer algo”.

Serve para:

Navegar entre telas do próprio app (Intent explícita).

Pedir ação para outro app: navegador, telefone, maps, câmera… (Intent implícita).

Utilizando Intents

🛠 Como implementar

Para abrir outra Activity (Intent explícita)

Passos:

Declare a nova Activity no [Link].

fi
fi
 Na Activity atual, na ação de um botão, crie a Intent especi cando:

Contexto (a Activity atual).

A classe da Activity que você quer abrir.

Chame o método para iniciar a Activity (startActivity).

Se precisar enviar dados:

Adicione “extras” à Intent (por exemplo, um id, um nome).

Na próxima Activity:

Recupere os dados recebidos pelos “extras”.

Para abrir outro app (Intent implícita)

Exemplo de casos da sua apostila: abrir navegador, discador, SMS, Maps, câmera etc.

Utilizando Intents

Passos genéricos:

Escolha a ação (ACTION_VIEW, ACTION_DIAL, ACTION_SENDTO,

ACTION_IMAGE_CAPTURE…).

Monte a Intent passando:

A ação.

Um dado (URI) se necessário (ex: [Link] [Link] geo: etc).

Chame startActivity.

Em alguns casos, prepare para receber o resultado (foto da câmera, arquivo escolhido), usando a
API de resultado (antigo startActivityForResult).

Para mandar dados de volta (Activity de resultado)

Na segunda Activity:

Monte uma Intent de retorno contendo as informações (por exemplo, item selecionado).

Chame setResult com um código de resultado e a Intent.

Chame nish() para fechar.

Na primeira Activity:

Implemente o callback de resultado (hoje via registerForActivityResult) para receber os dados.

👉 Na prova, lembra de citar:

“Intent explícita: abre activities internas. Intent implícita: delega ações para outros apps usando
ACTION_VIEW, ACTION_SENDTO, ACTION_DIAL etc.”

4⃣ SharedPreferences
💡 Conceito
fi
fi
 SharedPreferences é um arquivo de con guração com dados simples e pequenos, no formato
chave valor:

Strings

Ints

Booleans

Floats
Perfeito para: lembrar login, tema escuro, ag “já viu o tutorial?”, etc.

A imagem que você mandou está exatamente com esse passo-a-passo.

🛠 Como implementar

Escolha o nome do arquivo

Ex: "con g_app", "login_prefs".

Para salvar dados

Peça ao contexto o objeto de SharedPreferences informando:

Nome do arquivo.

Modo de acesso (geralmente MODE_PRIVATE).

Pegue o “editor” dessas preferências.

Use métodos como:

putString("chave", valor)

putInt("chave", valor)

putBoolean("chave", valor)

Con rme a gravação chamando apply() ou commit().

Para ler dados

Novamente, obtenha o SharedPreferences com o mesmo nome.

Use:

getString("chave", valorPadrao)

getInt("chave", valorPadrao)

getBoolean("chave", valorPadrao)

Se a chave não existir, retorna o valor padrão.

Para apagar um valor especí co

Pegue o editor.
fi
fi
fi
fi
fl
 Use algo tipo remove("chave").

Con rme com apply()/commit().

Para apagar tudo

Pegue o editor.

Use clear().

Con rme.

👉 Dica:
Sempre use as mesmas chaves ("email", "temaEscuro") em todo o app, e preferencialmente
constantes, pra não errar escrita.

5⃣ Room – Conceito e Implementação

💡 Conceito

Room é uma camada por cima do SQLite, parte do Android Jetpack.

Ele faz você trabalhar com classes e anotações, em vez de SQL “na unha”.
Serve para:

Guardar dados localmente (o ine).

Fazer CRUD (Create, Read, Update, Delete) com segurança de tipos.

Os arquivos que você mandou já montam um CRUD completo e um exemplo com cache de
Retro t.

🛠 Como implementar (passo a passo)

Adicionar dependências no Gradle

No [Link] (módulo app), adicionar as bibliotecas Room (runtime e compiler) e o plugin kapt.

Sincronizar o projeto.

Criar a Entidade (tabela)

Criar uma classe de dados que representa a tabela (ex: User, Post).

Anotar a classe com @Entity.

Escolher um campo como chave primária (@PrimaryKey).

Cada propriedade da classe vira uma coluna da tabela.

Criar o DAO (Data Access Object)

Criar uma interface com a anotação @Dao.

Dentro dela, escrever métodos para:

Inserir (@Insert).

Buscar (@Query com SELECT).

fi
fi
fi
ffl
Atualizar (@Update ou @Query UPDATE).

Deletar (@Delete).

Esses métodos podem ser suspend para serem usados com corrotinas.

Criar a classe do Banco de Dados

Criar uma classe abstrata que estende RoomDatabase com anotação @Database.

Nela, lista as entidades (ex: [User::class]) e de ne um version.

Adiciona um método abstrato que retorna o DAO (ex: fun userDao(): UserDao).

No companion object, implementa um método getDatabase(context) que:

Usa [Link] para criar ou recuperar uma instância única do banco (padrão
Singleton).

Consumir o Room na Activity / ViewModel / Repository

Obter a instância do banco com [Link](this) (ou via Application).

Pegar o DAO correspondente ([Link]()).

Fazer as operações de banco em corrotinas (ex: [Link]):

Adicionar registro.

Buscar lista e atualizar a UI.

Opcional, mas muito comum:

Criar um Repository que recebe DAO e/ou Retro t.

Na Activity, chamar somente os métodos do repository (mais organizado).

O seu anexo adicional mostra exatamente esse padrão: chama API com Retro t, salva o
resultado no Room, e se der erro usa os dados já salvos.

ROOM- ANEXO ADICIONAL

👉 Pra prova:

“Room é uma biblioteca que facilita o uso de SQLite com entidades (@Entity), DAOs (@Dao) e
uma classe de banco (@Database), permitindo armazenar dados localmente, inclusive como
cache de chamadas de API.”

6⃣ Menu
💡 Conceito

Menu é aquele conjunto de opções (três pontinhos no topo, ou ícones na AppBar) que permite ao
usuário acessar ações como “Con gurações”, “Sair”, “Ajuda”.

🛠 Como implementar um Options Menu simples

Criar a pasta e o arquivo de menu

fi
fi
fi
fi
 Em res/, criar a pasta menu (se não existir).

Criar um arquivo XML (ex: menu_main.xml).

Dentro desse XML, de nir itens <item> com:

id (para identi car qual item foi clicado).

title (texto exibido).

(opcional) icon (ícone na barra).

In ar o menu na Activity

Na Activity, sobrescrever o método responsável pelo menu.

Dentro desse método, usar o menuIn ater para carregar o XML de menu que você criou.

Retornar true para indicar que o menu foi criado.

Tratar cliques nos itens

Ainda na Activity, sobrescrever o método que é chamado quando o usuário clica em algum item
do menu.

Veri car qual id do item foi clicado.

Tomar a ação correspondente:

Abrir outra Activity com Intent.

Mostrar um Toast.

Abrir um diálogo, etc.

Menus especí cos (opcional para prova)

Menu contextual (aparece ao segurar em cima de um item).

Navigation Drawer e BottomNavigation usam outro tipo de con guração, mas a lógica básica é a
mesma: XML de menu + código que trata as seleções.

👉 Se cair:

“Para implementar um menu, crio um XML em res/menu, in ando esse menu em

onCreateOptionsMenu e tratando os cliques em onOptionsItemSelected.”

7⃣ Grá co (MPAndroidChart)
💡 Conceito

Para exibir grá cos no Android, você está usando a biblioteca MPAndroidChart. Ela suporta
vários tipos de grá cos: barras, linha, pizza, radar, dispersão, etc.

GRÁFICO

🛠 Como implementar (passo a passo)

Adicionar dependência no Gradle

fl
fi
fi
fi
fi
fi
fi
fi
fl
fl
fi
 No [Link] (Module: app), adicionar a dependência da MPAndroidChart.

No [Link], incluir o repositório [Link], além do google() e mavenCentral().

Sincronizar o projeto.

Con gurar cores básicas

No res/values/[Link], garantir que existam as cores necessárias (black, white, orange, blue
etc.), como está no material.

Adicionar o componente do grá co no XML

No layout da Activity (ex: activity_main.xml), colocar o componente correspondente:

BarChart (barras).

LineChart (linha).

PieChart (pizza).

De nir layout_width e layout_height.

Preparar os dados na Activity

Pensar quais valores você quer mostrar (por exemplo, vendas por mês).

Montar uma lista de pontos (x, y) ou valores com rótulos, de acordo com o tipo de grá co:

Para barra, cada ponto tem posição e valor.

Para linha, cada ponto tem valor ao longo de um eixo.

Para pizza, cada valor representa uma fatia do total.

Agrupar essas entradas em um “dataset” e depois em um “data” (objeto de dados do grá co).

Conectar os dados ao grá co

Pegar a referência do grá co na Activity.

Atribuir o objeto de dados ao grá co.

Opcionalmente:

Con gurar legenda, descrição, animação, eixos.

Chamar o método para redesenhar o grá co (invalidate/refresh).

Tipos suportados (prova)

BarChart (barras)

LineChart (linha)

PieChart (pizza)

RadarChart (radar)
fi
fi
fi
fi
fi
fi
fi
fi
fi
fi
ScatterChart (dispersão)

HorizontalBarChart (barras horizontais)

GRÁFICO

👉 Se cair:

“Para usar grá cos, adiciono a MPAndroidChart no Gradle, coloco o componente de grá co no
layout, preparo uma lista de valores, crio um conjunto de dados, atribuo esse conjunto ao grá co
e atualizo a visualização.”
fi
fi
fi