Pular para o conteúdo

Curso Desenvolvimento Móvel com Google Android em Kotlin

FD9E034F-C706-472D-ABA4-310433A703E5 Created with sketchtool. 40 horas/curso
Veja as próximas turmas

O que você vai fazer

Para quem é esse curso?

Este curso é destinado para quem quer aprender a fazer seu aplicativo em Android, utilizando as mais recentes ferramentas e bibliotecas recomendadas pelo Google, como as Architecture Components. O curso também ensina a linguagem de Kotlin, que está sendo cada vez mais utilizada em aplicativos Android no mercado, além das boas práticas de código Android.

Para aproveitar melhor o curso recomendamos que você tenha conhecimento em

Curso Java e Orientação a Objetos

Próximas turmas

Selecione a cidade e os períodos de sua preferência

Qual cidade você pode ir?
Quais períodos você prefere?
Ver turmas encontradas

Nós encontramos essas turmas:

Não achou a turma ideal pra você? Consulte outras turmas e horários.

Entre em contato

O que os alunos falam

Wanderson Macêdo

Com este curso me sinto capaz de desenvolver os aplicativos legais que sempre quis fazer :)

Guilherme Fernandes da Silva

Ótimo atendimento de toda equipe da Caelum, professor com boa didática e muito prestativo.

Luiz Eduardo Alves Coutinho

Estou começando a desenvolver mobile agora e esse curso abriu um leque de conhecimento, estou curtindo mais ainda depois de ter feito o curso!

Conteúdo detalhado do curso FJ-57

    Criando nosso projeto no Android Studio

  1. Dispositivos Android
  2. A linguagem Kotlin
  3. Instalação do Android
  4. Criação de um projeto
  5. Escolha da versão alvo do projeto
  6. Emuladores de Android
  7. Exercício: Criando um projeto

    Manipulando nossa primeira Activity

  1. Customizando telas
  2. Componentes de tela
  3. Mostrando campo de texto
  4. Trabalhando com ConstraintLayout no editor visual
  5. Exercício: Modelando o layout atráves do editor visual
  6. Mostrando e esperando clique do botão
  7. Algumas sintaxes do Kotlin
  8. Exibindo aviso temporário ao usuário com Toast
  9. Exibindo aviso ao programador com Log
  10. Exercício: Fazendo a primeira interação com o sistema

    Criando um Fluxo no Aplicativo

  1. Entendendo o que é uma Activity
  2. Modificando layouts pelo xml
  3. Criando listas com o ListView
  4. Acessando componentes da tela com Kotlin
  5. Exercício: Exibindo uma lista no Android
  6. Criando botão seguindo o Material Design
  7. Exibindo aviso ao usuário com Snackbar
  8. Exercício: Adicionando botão flutuante
  9. Trocando de tela com Intents
  10. Voltando pra tela anterior
  11. Exercício: Trocando de Activity
  12. Deixando opção de salvar na ActionBar
  13. Atrelando lógica a um item do menu de opções
  14. Incluindo opção de voltar pra tela anterior
  15. Exercício: Melhorando o botão de salvar

    Introdução a Arquitetura no Android

  1. Criando classes de modelo com data class
  2. Exercício: Criando nosso primeiro modelo de maneira simples
  3. Persistindo dados localmente no Android
  4. Melhorias com Room
  5. Mapeando o Tweet com uma tabela no banco
  6. Definindo nosso Dao
  7. Definindo nosso Database
  8. Criando uma Factory usando o conceito de companion object
  9. Avisando em qual banco será executada a inserção
  10. Exercício: Salvando o primeiro tweet com Room
  11. Fazendo consultas com Room
  12. Mostrando lista do banco na tela
  13. Exercício: Exibindo listagem com Room
  14. Entendendo o ciclo de vida das Activities
  15. Exercício: Exibindo listagem de maneira correta
  16. Conhecendo os componentes de arquitetura
  17. Trabalhando com o contexto de aplicação
  18. Gerenciando objetos no ciclo de vida
  19. Facilitando o trabalho com o ViewModel
  20. Fabricando um ViewModel com ViewModelProvider
  21. Separando as responsabilidades com o Repository
  22. Automatizando o acesso aos dados com o LiveData
  23. Exercício: Deixando nosso sistema mais maleável a mudanças
  24. Atendendo ao clique na lista
  25. Mostrando um alerta ao usuário
  26. Implementando a lógica de exclusão
  27. Exercício: Possibilitando a exclusão de um tweet

    Utilizando a camera

  1. Adicionando um item ao menu da tela de cadastro
  2. Trabalhando com ícones
  3. Abrindo um aplicativo de câmera
  4. Exercício: Abrindo a câmera
  5. Informando onde a foto deve ser salva
  6. Utilizando um provedor de arquivos
  7. Adicionando a componente de imagem na tela
  8. Melhorando o layout
  9. Manipulando a imagem
  10. Exercício: Passando o caminho da foto para a câmera
  11. Verificando se a foto foi tirada
  12. Exercício: Prevendo quando o usuário cancelar a ação
  13. Adicionando foto ao Tweet
  14. Trabalhando com valores que podem ser nulos no Kotlin
  15. Atualizando a tabela no banco de dados
  16. Alterando a versão do banco de dados
  17. Pegando a imagem da tela
  18. Salvando a foto no banco de dados
  19. Exercício: Salvando a foto

    Personalizando nossa lista

  1. Personalizando a lista
  2. Definindo o layout de um item
  3. Criando um Adapter próprio
  4. Inflando um xml de layout com LayoutInflater
  5. Mostrando a imagem em cada item
  6. Exercício: Exibindo a foto na lista

    Desacoplando comportamentos com Fragments

  1. Separando o armazenamento dos tweets
  2. Exercício: Pegando o projeto
  3. Adicionando opções para o usuário na parte de baixo da tela
  4. Melhorando o layout
  5. Criando botão de novo tweet
  6. Exercício: Deixando nosso layout mais real
  7. Alterando apenas parte da tela
  8. Reaproveitando parte de uma tela em outra
  9. Organizando a tela com Fragments
  10. Gerenciando os fragmentos de tela
  11. Exercício: Criando o primeiro fragment
  12. Criando o Fragment de filtro
  13. Definindo uma barra de busca
  14. Colocando menu em um Fragment
  15. Fazendo a lógica de busca com SearchView
  16. Exercício: Fazendo a parte de busca

    Manipulando dados reais

  1. Modelando o usuário
  2. Criando a tela de login
  3. Mudando a tela de início
  4. Customizando os botões usando as componentes de arquitetura
  5. Exercício: Criando nosso usuário
  6. Criando usuário no servidor
  7. Fazendo requisições com Retrofit
  8. Customizando requisições
  9. Realizando requisições em segundo plano
  10. Recebendo funções como parâmetros de outra função
  11. Logando o usuário no servidor
  12. Verificando se usuário está logado com MutableLiveData
  13. Pedindo para usar a internet
  14. Exercício: Fazendo o Login do usuário
  15. Exercício Opcional: Fazendo o Logout do usuário
  16. Criando o serviço de tweets
  17. Implementando a requisição de inserção no servidor
  18. Armazenando o dono do tweet
  19. Verificando sucesso e falha na requisição
  20. Implementando a requisição de listagem dos tweets
  21. Isolando a lógica da Factory com objeto do Kotlin
  22. Atualizando a lista da tela com LiveData
  23. Exercício: Trazendo os tweets da Api
  24. Usando swipe para atualizar a lista
  25. Exercício: Atualizando os tweets

    Trabalhando com Maps

  1. Usando o Android Studio para configurar o Google Maps
  2. Exercício: Configurando o Google Maps
  3. Utilizando o fragmento de mapa da Google
  4. Exercício: Exibindo o mapa

    Trabalhando com GPS

  1. Baixando as bibliotecas para escutar o GPS
  2. Pedindo a localização atual ao GPS
  3. Recebendo a resposta do GPS
  4. Armazenando a localização no tweet
  5. Exercício: Fazendo nosso tweet ter posição
  6. Esperando o mapa ficar pronto para manipulá-lo
  7. Exibindo pontos específicos
  8. Mostrando a localização de cada tweet
  9. Exercício: Exibindo no mapa os tweets

* Apêndices são conteúdos adicionais que não fazem parte da carga horária regular do curso. São conteúdos extras para direcionar seus estudos após o curso.

Não encontrou o curso que procura? Conheça a Alura, a plataforma online da Caelum

Conheça a Alura