0:00:00 - Desenvolvimento Android com Java - Treinamento Completo - Apresentação

0:04:07 - O Que Aprenderemos neste Treinamento?

0:07:39 - Projetos que Criaremos

0:08:32 - Compilador Online de Java

0:10:20 - Regras Básicas de Programação

0:13:57 - Criando um Novo Programa em Java

0:22:16 - Variáveis no Java

0:33:13 - Comentando o Código

0:34:42 - Operações com Strings

0:40:35 - Comandos Unicode para Strings

0:43:12 - Convertendo os Tipos de Variáveis

0:48:26 - Gravando o Projeto

0:50:49 - Operadores Matemáticos

0:59:31 - Números Aleatórios

1:02:48 - Operadores de Comparação

1:05:57 - Operadores Lógicos

1:10:11 - Estrutura de Condição If

1:17:59 - PROJETO #01 - Jogo do Par ou Ímpar

1:24:48 - Estrutura Switch

1:27:43 - PROJETO #02 - Jogo do Jo-Ken-Pô

1:41:11 - Estrutura de Repetição For

1:47:30 - Estrutura de Repetição While

1:54:07 - Listas Vetores ou Arrays

2:00:17 - Percorrendo uma Lista com For

2:01:07 - Repetição For em Arrays

2:02:21 - Array Multidimensional ou Matriz

2:04:55 - Percorrendo uma Matriz com Loops Aninhados

2:08:24 - Método Arrays to String

2:10:19 - Métodos com Strings Apresentação

2:11:18 - Métodos com Strings Length e IndexOf

2:14:26 - Método Split

2:17:35 - CharAt e CharacterToString

2:22:12 - Argumentos da Linha de Comando

2:26:52 - Percorrendo uma Lista com Loop For

2:27:44 - PROJETO #03 - Sorteio de Nomes

2:34:15 - ArrayList - Introdução

2:40:55 - PROJETO #04 - Busca por Nome e ID

2:57:51 - Procedimentos

2:59:59 - Passagem de Argumentos

3:01:28 - Função e Retorno

3:09:01 - PROJETO #05 - Algoritmo para Validar o CPF

3:13:11 - Convertendo Strings em Ints

3:26:58 - Calculando os Dígitos Finais

3:41:51 - Imprimindo Números na Formatação do CPF

3:54:23 - PROJETO #06 - Calculando os Números Primos

4:11:28 - Criando e Utilizando Classes

4:18:26 - Sobrecarga de Função - Overloading Function

4:21:20 - Metodo Construtor

4:24:05 - Hierarquia - Extendendo Classes

4:29:34 - Sobrescrevendo Métodos - Override Methods

4:35:59 - Modificadores de Acesso

4:40:20 - Modificador Final - Constantes

4:42:44 - Atributo Estático

4:46:33 - Classe Interna e Estática

4:50:35 - Modelos de Dados

5:00:20 - Criando o Modelo de Dado - Contato

5:08:34 - Método para Adicionar Contato

5:11:45 - Imprimindo Lista de Contatos

5:14:26 - Método para Remover Contato

5:21:29 - PROJETO #07 - Sistema de Busca - Método para Buscar Nome

5:30:26 - Argumentos para Instruções do Programa

00:00 - Introdução ao Android Studio e Primeiros Passos

00:52 - Download e Instalação do Android Studio (Windows)

02:06 - Requisitos de Hardware (Memória RAM)

07:29 - Criando o Primeiro Projeto (Empty Activity)

12:06 - Configurando o SDK e AVD Manager (Simulador)

13:29 - Executando a Aplicação Hello World no Simulador

15:58 - Anatomia e Estrutura Básica do Projeto

20:27 - Arquivo de Layout (Activity Main) e Paleta

24:00 - Adicionando um Botão e Editando Componentes

24:52 - Código Java: Controlando o Clique do Botão (On Click Listener)

25:37 - Usando o Logcat para Debug e Filtro de Mensagens

35:09 - Guia de Instalação do Android Studio no Linux (Fedora)

58:35 - Habilitando o Developer Mode no Dispositivo Físico

01:01:31 - Instalando e Testando o App no Celular (APK por E-mail)

00:03 - Introdução ao Aplicativo Contador de Pessoas

00:24 - Criando Nova Aplicação (App 01)

01:44 - Limpando o Template Padrão do Aplicativo

02:45 - Criando o Layout (Inserindo Botões e Texto)

03:43 - Personalizando Cores e Labels (Homem, Mulher, Reset)

04:39 - Ajustando o Layout e Tamanhos no modo de Texto (XML)

06:21 - Identificando Componentes (Definindo IDs)

07:41 - Instanciando Componentes no Java (Text View e Buttons)

11:08 - Declarando Variáveis (int númeroHomem, númeroMulher, númeroPessoas)

12:34 - Função onClickListener para Botão Homem (Lógica de Incremento)

14:33 - Corrigindo Erro de Variável (Uso de 'final')

17:02 - Implementando a Lógica para o Botão Mulher

19:25 - Implementando a Função de Reset

21:04 - Próximos Passos

00:05 - Introdução e a História do App de US$ 47 mil

02:57 - Iniciando o Projeto no Android Studio

03:17 - Como Mudar o Nome e o Ícone da Aplicação

09:33 - ConstraintLayout: Entendendo o Layout Responsivo

17:18 - Removendo a Action Bar Padrão (Activity vs. AppCompatActivity)

25:18 - Configurando a Imagem da Seta (ImageView)

30:59 - Programação em Java: Declarando Componentes

35:12 - Implementando o Evento de Clique na Tela (onClick)

37:18 - Lógica do Sorteio Aleatório (Math.random)

40:23 - Adicionando Animações (Animation)

43:04 - Configuração de Estado Inicial e Visibilidade

45:21 - Usando Animation Listener para Eventos da Animação

48:39 - Aplicando Delay com Timer e Finalização

00:05 - Início do Projeto Jó Ken Pô no Android Studio

01:12 - Importando Gráficos (PNGs) e Áudio (MP3) para o Projeto

01:39 - Configurando o Ícone da Aplicação (Image Asset)

03:34 - Configurando o Layout da Tela Principal (Activity Main)

04:16 - Alinhamento e Distribuição dos Botões com Chain e ConstraintLayout

07:48 - Trocando Imagens (ImageButton) e Cores de Fundo no Layout

10:39 - Adicionando Imagens do Jogador 1, Jogador 2 e o "VS" (ImageView)

16:27 - Atribuindo IDs aos Componentes e Declarando Variáveis em Java

18:25 - Inicializando Variáveis e Implementando Evento de Clique (onClick)

24:14 - Evitando o Reset da View na Mudança de Orientação (Android Manifest)

25:44 - Implementando Animação de Fade (Sumir/Aparecer)

30:18 - Sorteando a Jogada do Inimigo (Número Randômico - Random)

36:18 - Verificando a Jogada e Definindo Vencedor (If/Else e Toast)

43:24 - Inserindo e Disparando um Som (MP3) com MediaPlayer

47:32 - Dica: Pausando o Som em Background (Métodos onDestroy)

00:00 - Introdução ao projeto da Calculadora

00:28 - Criando o projeto e limpando o template inicial

02:25 - Configurando o Layout com Grid Layout

03:22 - Adicionando e estilizando os botões da calculadora

06:34 - Criando o campo de exibição de resultados (TextView)

08:20 - Configurando eventos de clique (onClick) e IDs

12:45 - Declarando variáveis e lógica no MainActivity.java

14:16 - Função Switch para identificar qual botão foi clicado

16:15 - Lógica da função de cálculo e conversão de tipos

19:14 - Gerenciando a entrada de números (Keyboard logic)

20:43 - Função para mostrar o resultado final

23:34 - Testando o aplicativo no simulador

25:01 - Desafio de lógica e considerações finais

0:00:00 - Introdução ao projeto e estrutura do App de Quiz 

0:01:28 - Configuração do Layout no Activity Main e limpeza de templates 

0:02:02 - Forçando a orientação da tela para horizontal (Landscape) no Manifest 

0:03:02 - Implementação de RadioGroups e RadioButtons para opções de resposta 

0:06:50 - Identificando componentes com IDs e criando o evento OnClick do botão 

0:09:42 - Declarando variáveis e criando Arrays para perguntas e gabarito 

0:13:28 - Configurando o Listener do RadioGroup para habilitar o botão OK 

0:16:16 - Criando a função de atualização dinâmica das perguntas e respostas 

0:21:40 - Gerenciando estados do botão (SetEnable) e limpeza de seleção 

0:24:06 - Lógica para armazenar as respostas do usuário em uma lista 

0:27:38 - Implementando a verificação de fim do quiz e limite de perguntas 

0:31:04 - Criando o loop de conferência de resultados e exibição de alerta final

0:00:05 - Introdução ao modelo de classes e padrão MVC 

0:01:25 - Como criar uma nova Java Class no Android Studio 

0:04:09 - Gerando Construtores automaticamente (Generate Constructor) 

0:05:30 - Implementando métodos Getter e Setter 

0:07:45 - Criando métodos personalizados e retornos de função 

0:09:40 - Conceitos de Herança: Usando "extends" para criar subclasses 

0:12:45 - Sobrescrita de métodos com @Override 

0:18:25 - Entendendo Arrays simples e suas limitações 

0:22:30 - Por que Arrays comuns causam crash na aplicação 

0:27:03 - Introdução aos ArrayLists: Listas dinâmicas e flexíveis 

0:30:30 - Operações com ArrayList: Adicionar, remover e acessar itens 

0:35:55 - Criando e manipulando uma lista de objetos complexos (ArrayList de Pessoa)

00:06 Visão Geral do Projeto (App de Cards e Listas)

00:39 Entendendo o Conceito de ListView e Padrão MVC

01:42 Inserindo o Componente ListView no Layout

04:45 Criando Array de Dados (Lista Simples)

05:35 Usando ArrayAdapter Simples

10:35 Implementando o Evento de Clique (onItemClickListener)

13:46 Criando o Layout Customizado da Célula (XML)

17:31 Estruturando o Modelo de Dados (Classe Personagem)

01:01:02 Testando e Ajustando a Célula Customizada

01:03:08 Revisão Final do Projeto e Encerramento

00:06 - Apresentação do Aplicativo (ListView e Detalhes)

01:15 - Entendendo a Navegação entre Activities

01:47 - Criando a Segunda Activity (SegundaTela)

03:34 - Navegando entre Telas com Intent

05:38 - Passando Parâmetros com Intent.putExtra()

07:00 - Resgatando Dados na Segunda Activity com Bundle

11:10 - Configuração Visual (Manifest, Layouts e Cores)

15:30 - Criando o Layout da Célula da Lista (minha_célula)

20:46 - Preparando o Layout da Tela de Detalhes

23:34 - Implementando a Lógica da Lista (Adapters e Dados)

31:07 - Implementando o Evento de Clique e Passando Dados

33:18 - Obtendo e Exibindo os Dados de Detalhe na Segunda Activity

37:18 - Ajustes Finais de Layout (Tela de Detalhes)

41:53 - Encerramento e Próximos Passos

00:05 - Introdução ao Armazenamento de Dados Permanentes no Android

00:49 - O que é SharedPreferences e uso para dados simples

01:35 - Implementando SharedPreferences: Inserindo e Resgatando Dados

04:24 - Introdução ao SQLite: Quando usar para grandes volumes de dados

06:04 - Conceitos Básicos de SQL e Estrutura de Tabela

07:51 - Criando o Banco de Dados SQLite (Open or Create Database)

08:42 - Executando comandos SQL: Criando a Tabela (CREATE TABLE)

10:30 - Inserindo Valores na Tabela (INSERT INTO)

11:44 - Lendo os Dados da Tabela com o Objeto Cursor (SELECT)

19:02 - Boas Práticas e Estrutura: Classe Configuração (Task Contract)

26:29 - Implementando a Classe Helper e Instanciando o Banco

28:51 - Função para Adicionar Item à Tabela (ContentValues)

34:47 - Função para Ler Dados do Banco (query e Cursor Loop)

40:20 - Função para Apagar Dados do Banco (DELETE FROM)

44:53 - Conclusão e Resumo dos Recursos Utilizados

00:02 - Demonstração e Apresentação do Aplicativo Final

01:08 - Início da Estrutura e Criação do Layout Principal

03:20 - Inicializando e fazendo o Casting dos Objetos (ListView, EditText, Button)

05:32 - Inicializando o Banco de Dados SQLite

07:13 - Criando a Tabela minhas_tarefas com ID (Auto Increment)

09:38 - Executando o Comando INSERT INTO (Inserir Dados)

12:18 - Executando o Comando SELECT e utilizando o Cursor para recuperar dados

18:57 - Estruturando o Código em Funções (carrega_tarefas, adicionar_nova_tarefa, apagar_tarefa)

27:15 - Criando o ArrayAdapter e os Arrays de Itens e IDs

31:56 - Setando o Adapter na ListView

33:51 - Criando a Função apagar_tarefa (Comando DELETE)

36:31 - Adicionando OnItemLongClickListener na Lista

38:31 - Dica SEO/Ordenação: Ordenando a Lista em Ordem Decrescente (ORDER BY ID DESC)

41:11 - Criando e Implementando o AlertDialog para confirmação de exclusão

00:02 - Demonstração e Apresentação do Aplicativo Final

01:08 - Início da Estrutura e Criação do Layout Principal

03:20 - Inicializando e fazendo o Casting dos Objetos (ListView, EditText, Button)

05:32 - Inicializando o Banco de Dados SQLite

07:13 - Criando a Tabela minhas_tarefas com ID (Auto Increment)

09:38 - Executando o Comando INSERT INTO (Inserir Dados)

12:18 - Executando o Comando SELECT e utilizando o Cursor para recuperar dados

18:57 - Estruturando o Código em Funções (carrega_tarefas, adicionar_nova_tarefa, apagar_tarefa)

27:15 - Criando o ArrayAdapter e os Arrays de Itens e IDs

31:56 - Setando o Adapter na ListView

33:51 - Criando a Função apagar_tarefa (Comando DELETE)

36:31 - Adicionando OnItemLongClickListener na Lista

38:31 - Dica SEO/Ordenação: Ordenando a Lista em Ordem Decrescente (ORDER BY ID DESC)

41:11 - Criando e Implementando o AlertDialog para confirmação de exclusão

00:04 - Introdução ao JSON para Aplicações (Quiz)

00:35 - O que é JSON (JavaScript Object Notation)?

01:35 - Estrutura Básica de um Arquivo JSON (Strings, Números, Booleanos)

04:13 - Criando a Estrutura JSON com Arrays e Objetos Complexos

08:38 - Validação de JSON com o Site JSON Lint

10:34 - Gerando uma URL para Consumo de JSON (JSON Generator)

13:50 - Lendo e Serializando Dados JSON no Android Studio (Java)

16:47 - Detalhe Importante: Escapando Aspas (Barra Invertida)

20:20 - Consumindo JSON Object e Obtendo Variáveis

25:35 - Manipulando JSON Array (Lista de Objetos)

34:50 - Obtendo JSON de uma URL/Web Service (JSON Task)

36:31 - Adicionando Permissão de Internet no Android Manifest

37:33 - Utilizando a Classe JsonTask (AsyncTask) para Conexão Assíncrona

00:06 - Introdução ao Projeto e Demonstração do App Quiz

01:46 - Conhecendo os Componentes: Progress Bar e Radio Button

10:05 - Configurações Iniciais do Aplicativo (Manifest, Ícone, Cores)

12:59 - Criação do Layout do Quiz

19:36 - Estruturando o JSON (Web Service) para Perguntas e Respostas

25:48 - Criando o Modelo de Dados "Questão" (Classe Java)

30:35 - Consumindo o JSON do Web Service com AsyncTask

33:18 - Serializando o JSON (JSONObject e JSONArray)

44:55 - Ajustes de Layout e Exibição do Título e Progress Bar

54:31 - Implementando os Eventos de Jogada e Controle de Rodadas

01:00:50 - Adicionando Animações (Fade In/Out) para Transição de Perguntas

01:15:44 - Implementando o Sistema de Pontuação e Fim de Jogo

01:27:30 - Finalizando com um Alerta Personalizado (AlertDialog) para Reiniciar o Jogo

00:05 - Introdução ao Material Design e Boas Práticas

01:46 - Componentes Nativos do Material Design (Toolbar, Recycler View e Card View)

03:22 - Consultando o Site Material.io: Cores e Ícones

05:30 - Criando um Novo Projeto e Templates do Android Studio

08:55 - Alterando o Tema (Theme) da Aplicação (Dark, Light, No Action Bar)

10:46 - Inserindo e Configurando a Toolbar Manualmente (XML)

13:16 - Inicializando a Toolbar via Código Java (setSupportActionBar)

15:52 - Adicionando um Menu de Opções na Toolbar (onCreateOptionsMenu)

23:50 - Detectando o Evento de Clique nos Itens do Menu (onOptionsItemSelected)

26:23 - Ativando o Botão de Voltar (Back Button/Home as Up)

29:07 - Inserindo Logotipo e Ajustando a Altura da Toolbar

33:15 - Conhecendo e Usando o CardView (Sombras e Cantos Arredondados)

00:05 - Criando o Layout da Célula (minha_célula.xml) e CardView

03:56 - Criando a Classe do Adaptador (MeuAdaptador)

05:17 - Implementando os Métodos Essenciais do Adapter

08:33 - Criando a Classe View Holder (MeuViewHolder)

15:42 - Atualizando os Dados no Método onBindViewHolder

23:25 - Configurando o LayoutManager na MainActivity

32:51 - Adicionando o Evento de Clique (onItemClickListener) na Lista

40:59 - Elemento Extra: Adicionando o Floating Action Button (FAB)

01:24 - Configurando a YouTube Android Player API no Projeto

04:00 - Gerando a Chave API Key no Google Developers Console

06:30 - Obtendo e Usando o Hash SHA-1 de Assinatura

09:35 - Inicializando e Implementando o YouTube Player View

15:29 - Corrigindo Erros (Extender YouTubeBaseActivity e Permissões)

18:21 - Carregando Imagens Externas com a Biblioteca Picasso

20:04 - Adicionando Dependência do Picasso no Gradle

25:35 - Capturando a Capa (Thumbnail) do Vídeo do YouTube via URL

00:03 - AssuntoTimecodeIntrodução e Visão Geral do Projeto

03:43 - Criação do Projeto e Telas Principais

06:10 - Criação de Layout de Célula Customizada (ListView)

09:30 - Configuração de Strings e Arrays

10:10 - Classes Adapter e Data Provider para a Lista

15:31 - Programação da Tela Principal (Animação e Clique)

23:10 - Criação da Tela de Exercícios e Lógica de Seleção (Switch)

37:32 - Carregando Vídeo do YouTube via WebView na Tela de Vídeos

43:25 - Implementação do Recurso de Locução (Text-to-Speech)

46:59 - Criação da Tela de Execução do Treino (Design)

01:00:25 - Programação da Lógica do Temporizador (CountDownTimer)

01:03:35 - Função Fim do Treino (Animação e Som com MediaPlayer)

01:07:51 - Demonstração do Aplicativo em Funcionamento

00:03 - Introdução ao LibGDX e Setup Inicial

04:45 - Estrutura do Projeto no Android Studio

06:49 - Entendendo as Funções create e render (Base do Jogo)

09:38 - Implementando Movimento e Animação de Objetos

13:11 - Garantindo a Velocidade Consistente com Delta Time

15:09 - Importando Gráficos (Assets) e Trocando a Orientação da Tela

29:01 - Criando Animação de Sequência de Frames (Passarinho)

34:28 - Implementando a Física de Queda (Gravidade) e Impulso (Toque)

44:00 - Criando Formas Geométricas para Detecção de Colisão

54:27 - Sistema de Pontuação e Textos (Score, Game Over)

01:00:59 - Lógica do Jogo (Estado: Parado, Jogando, Game Over)

01:15:25 - Ajustes Finais (Sons e Ícone)

01:21:56 - Publicação na Google Play Store (Assinatura e Upload)

01:27:07 - Gerando e Alinhando o APK Assinado (Signed/Zipalign)