Conceitos básicos do Kotlin para Android 01.1: introdução

Este codelab faz parte do curso Conceitos básicos do Kotlin para Android. Você vai aproveitar mais este curso se fizer os codelabs em sequência. Todos os codelabs do curso estão listados na página inicial dos codelabs de princípios básicos do Kotlin para Android.

Introdução

Neste codelab, você vai criar e executar seu primeiro app Android, o HelloWorld, em um emulador e em um dispositivo físico. Você também vai ver como funciona um projeto Android.

O que você já precisa saber

• Você precisa entender o processo geral de desenvolvimento de software para apps orientados a objetos usando um ambiente de desenvolvimento integrado (IDE, na sigla em inglês), como o Android Studio.
• É necessário ter pelo menos um ano de experiência em programação orientada a objetos, com pelo menos um conhecimento de Java e Kotlin.

O que você vai aprender

• Como criar um app Android básico no Android Studio.
• Como criar um projeto Android usando um modelo.
• Como encontrar os principais componentes de um projeto Android.
• Como executar um app Android em um emulador ou dispositivo físico.

Atividades do laboratório

• Crie um projeto Android e um app padrão chamado HelloWorld.
• Crie um emulador (dispositivo virtual) para executar o app no computador.
• Execute o app HelloWorld em dispositivos virtuais e físicos.
• Confira o layout do projeto.
• Analise o arquivo AndroidManifest.xml.

O app HelloWorld mostra a string "Hello World" na tela de um dispositivo virtual ou físico Android. Esta é a aparência do app:

Nesta tarefa, você vai criar um projeto de app para verificar se o Android Studio está instalado corretamente.

1. Abra o Android Studio, se ele ainda não estiver aberto.
2. Na caixa de diálogo principal Welcome to Android Studio, clique em Start a new Android Studio project.
   
   
3. A caixa de diálogo Escolher seu projeto aparece. Selecione Empty Activity, conforme mostrado abaixo, e clique em Next.
   
   
   
   Uma Activity é uma única ação focada que o usuário pode realizar. Todo app precisa ter pelo menos uma atividade como ponto de entrada. Pense nessa atividade de ponto de entrada como a função main() em outros programas. Normalmente, uma atividade tem um layout associado que define como os elementos da interface do usuário (UI) aparecem em uma tela. O Android Studio oferece vários modelos Activity para ajudar você a começar.
   
4. Na caixa de diálogo Configure seu projeto, insira "HelloWorld" em Nome.
   
   
5. Aceite o android.example.com padrão para Domínio da empresa ou crie um domínio exclusivo. Esse valor mais o nome do app é o nome do pacote dele. Se você não planeja publicar o app, aceite o padrão. É possível mudar o nome do pacote do app depois, mas isso dá mais trabalho.
6. Verifique se o Local de salvamento padrão é onde você quer armazenar o app. Caso contrário, mude o local para o diretório de sua preferência.
7. Defina Language como Kotlin.
8. Verifique se o nível mínimo da API é API 19: Android 4.4 (KitKat). Na época em que este codelab foi escrito, o Android Studio indicou que, com esse nível de API, o app seria executado em aproximadamente 95,3% dos dispositivos.
   Você vai aprender mais sobre níveis mínimos de API em um codelab posterior. Para saber mais agora, clique em Ajude-me a escolher, que abre uma janela com informações sobre os níveis de API.)
   
9. Marque a caixa de seleção Usar artefatos do AndroidX.
10. Deixe todas as outras caixas de seleção desmarcadas e clique em Concluir. Se o projeto exigir mais componentes para o SDK de destino escolhido, o Android Studio os instalará automaticamente, o que pode levar algum tempo. Siga as instruções e aceite as opções padrão.

O Android Studio vai criar seu projeto, o que pode levar algum tempo. Você não deve receber nenhum erro. Se aparecerem avisos, ignore-os.

Nesta tarefa, você vai conhecer o projeto HelloWorld no Android Studio e aprender os conceitos básicos de desenvolvimento com o Android Studio.

Etapa 1: analisar o painel "Projeto"

1. Se a guia Projeto ainda não estiver selecionada, selecione-a. A guia Project está na coluna de guias vertical no lado esquerdo da janela do Android Studio. O painel "Projeto" é aberto.
   
   
   
2. Para ver o projeto como uma hierarquia padrão do Android, selecione Android no menu suspenso na parte de cima do painel "Projeto". Android é o padrão. É possível ver os arquivos do projeto de várias maneiras, incluindo como eles aparecem na hierarquia do sistema de arquivos. No entanto, é mais fácil trabalhar com o projeto usando a visualização do Android.
   
   

Observação:este e outros codelabs se referem ao painel "Projeto", quando definido como Android, como o painel Projeto > Android.

Etapa 2: conhecer a pasta do app

Todo o código e os recursos do app estão localizados na pasta app.

1. No painel Project > Android, abra a pasta app. Dentro da pasta app, há quatro subpastas: manifests, java, generatedJava e res.
2. Expanda a pasta java e depois a pasta com.example.android.HelloWorld para ver o arquivo Kotlin MainActivity.
   
   
   
   A pasta java contém todo o código Kotlin principal de um app Android. Há motivos históricos para que o código Kotlin apareça na pasta java. Essa convenção permite que o Kotlin interaja perfeitamente com o código escrito na linguagem de programação Java, mesmo no mesmo projeto e app.
   
   Os arquivos de classe do seu app estão contidos em três subpastas, conforme mostrado na figura acima. A pasta com.example.hello.helloworld (ou o nome de domínio especificado) contém todos os arquivos de um pacote de app. Em particular, a classe MainActivity é o principal ponto de entrada do app. Você vai aprender mais sobre MainActivity no próximo codelab. As outras duas pastas na pasta java são usadas para código relacionado a testes, como testes de unidade.

Observação:no sistema de arquivos, os arquivos Kotlin têm uma extensão .kt e um ícone K. Na visualização do projeto, o Android Studio mostra o nome da classe (MainActivity) sem a extensão.

3. Observe a pasta generatedJava. Essa pasta contém arquivos que o Android Studio gera ao criar o app. Não edite nada nela, porque suas mudanças podem ser substituídas quando você recriar o app. No entanto, é útil conhecer essa pasta quando você precisa consultar esses arquivos durante a depuração.

Etapa 3: explorar a pasta "res"

1. No painel Project > Android, abra a pasta res.
   
   A pasta res contém recursos. Os recursos no Android são conteúdo estático usado nos apps. Os recursos incluem imagens, strings de texto, layouts de tela, estilos e valores, como cores hexadecimais ou dimensões padrão.
   
   Os apps Android separam o código Kotlin e os recursos o máximo possível. Isso facilita muito a localização de todas as strings ou ícones usados na interface do app. Além disso, quando você muda um desses arquivos de recursos, a mudança entra em vigor em todos os lugares em que o arquivo é usado no app.
2. Na pasta res, abra a pasta layout para ver o arquivo activity_main.xml.
   
   
   

Seu Activity geralmente está associado a um arquivo de layout da interface, definido como um arquivo XML no diretório res/layout. Esse arquivo de layout geralmente recebe o nome da atividade. Neste caso, o nome da atividade é MainActivity, então o layout associado é activity_main.

Etapa 4: explorar a pasta "manifests" e o AndroidManifest.xml

A pasta manifests contém arquivos que fornecem informações essenciais sobre o app para o sistema Android.

1. Expanda a pasta manifests e clique duas vezes em AndroidManifest.xml para abrir. O arquivo AndroidManifest.xml inclui detalhes que o sistema Android precisa para executar o app, incluindo quais atividades fazem parte dele.
   
   
   
2. Observe que MainActivity é referenciado no elemento <activity>. Todos os Activity no app precisam ser declarados no manifesto. Confira um exemplo para MainActivity:

<activity android:name=".MainActivity">
   <intent-filter>
       <action android:name="android.intent.action.MAIN"/>

       <category android:name="android.intent.category.LAUNCHER"/>
   </intent-filter>
</activity>

3. Observe o elemento <intent-filter> dentro de <activity>. Os elementos <action> e <category> nesse filtro de intent informam ao Android onde iniciar o app quando o usuário clica no ícone do iniciador. Você vai aprender mais sobre filtros de intent em um próximo codelab.

O arquivo AndroidManifest.xml também é o lugar onde você define as permissões necessárias para o app. As permissões incluem a capacidade do app de ler contatos do smartphone, enviar dados pela Internet ou acessar hardware, como a câmera do dispositivo.

O Gradle é um sistema de automação de builds que usa uma linguagem específica de domínio para descrever a estrutura, a configuração e as dependências do projeto do app. Ao compilar e executar o app, você verá informações sobre o build do Gradle em execução. Você também encontra informações sobre o Android Package Kit (APK) que está sendo instalado. O APK é o formato de arquivo de pacote que o sistema operacional Android usa para distribuir e instalar apps para dispositivos móveis.

Conheça o sistema Gradle:

1. Expanda a pasta Gradle Scripts. No painel Project > Android, essa pasta contém todos os arquivos necessários para o sistema de build.
   
   
   
2. Procure o arquivo build.gradle(Project: HelloWorld).
   
   Ele contém as opções de configuração comuns a todos os módulos que compõem seu projeto. Todo projeto do Android Studio contém um único arquivo de build do Gradle de nível superior. Esse arquivo define os repositórios e as dependências do Gradle que são comuns a todos os módulos do projeto.
3. Procure o arquivo build.gradle(Module:app).
   
   Além do arquivo build.gradle no nível do projeto, cada módulo tem um arquivo build.gradle próprio. O arquivo build.gradle de nível de módulo permite configurar as opções de build para cada módulo. O app HelloWorld tem apenas um módulo, que é o próprio app. Esse arquivo build.gradle é o que você mais edita ao mudar as configurações de build no nível do app. Por exemplo, você edita esse arquivo build.gradle quando muda o nível do SDK compatível com seu app ou quando declara novas dependências na seção dependencies. Você vai aprender mais sobre esses dois aspectos em um próximo codelab.

Nesta tarefa, você vai usar o AVD Manager para criar um dispositivo virtual (um emulador). O dispositivo virtual simula a configuração de um tipo específico de dispositivo Android. Você usará esse dispositivo virtual para executar o app.

O Android Emulator é um aplicativo independente com os próprios requisitos de sistema. Os dispositivos virtuais podem ocupar muito espaço em disco. Se tiver problemas, consulte Executar apps no Android Emulator.

Etapa 1: criar um Dispositivo virtual Android (AVD)

Para executar um emulador no computador, é preciso criar uma configuração que descreva o dispositivo virtual.

1. No Android Studio, selecione Tools > AVD Manager ou clique no ícone AVD Manager na barra de ferramentas. A caixa de diálogo Your Virtual Devices vai aparecer. Se você já tiver criado dispositivos virtuais, a caixa de diálogo vai mostrá-los (como na figura abaixo). Caso contrário, uma lista em branco vai aparecer.
   
   
   
2. Clique em +Create Virtual Device na parte de baixo à esquerda da caixa de diálogo. A caixa de diálogo Select Hardware aparece com uma lista de dispositivos de hardware pré-configurados. Para cada dispositivo, a tabela tem uma coluna para o tamanho diagonal da tela (Tamanho), a resolução da tela em pixels (Resolução) e a densidade de pixels (Densidade).
   
   
3. Selecione um dispositivo, como Nexus 5x ou Pixel XL, e clique em Next. A caixa de diálogo System Image é exibida.
4. Clique na guia Recommended e escolha qual versão do sistema Android executar no dispositivo virtual (como Pie).
   
   
   

Observação: muito mais versões do sistema Android estão disponíveis do que as exibidas na guia Recommended. Para vê-las, consulte as guias x86 Images e Other Images.

Essas imagens usam muito espaço em disco, então apenas algumas fazem parte da instalação original. Se o link Download estiver visível ao lado de uma imagem do sistema que você quer usar, isso significa que ela não está instalada. Clique no link para iniciar o download, que pode levar muito tempo. Quando o download for concluído, clique em Finish.

5. Depois de escolher uma imagem do sistema, clique em Próxima. A caixa de diálogo Dispositivo virtual Android (AVD) é aberta. Verifique a configuração e clique em Concluir.

Etapa 2: executar o app no dispositivo virtual

Nesta tarefa, você vai executar o novo app.

1. No Android Studio, selecione Run > Run app ou clique no ícone Run Run app ou clique no ícone Run [ICON HERE] na barra de ferramentas. [IMAGEINFO]: ic_run.png, ícone Run do Android Studio" style="width: 24.00px" src="img/6c65750f2ce7f651.png"> na barra de ferramentas. A caixa de diálogo Select Deployment Target aparece e avisa que não há dispositivos disponíveis. Esse aviso aparece se você não tiver um dispositivo físico conectado ao computador de desenvolvimento ou se ainda não tiver iniciado um dispositivo virtual.
2. Na caixa de diálogo Selecionar alvo da implantação, em Dispositivos virtuais disponíveis, selecione o dispositivo virtual que você criou. Clique em OK.
   
   
   
   O emulador é iniciado e processado como um dispositivo físico. Dependendo da velocidade do seu computador, esse processo pode demorar um pouco. O app é criado e, quando o emulador está pronto, o Android Studio faz upload do APK do app para o emulador e o executa.
   
   O app HelloWorld vai aparecer como mostrado na figura a seguir.
   
   

Nesta tarefa, você vai executar o app em um dispositivo móvel físico, como um smartphone ou tablet, se tiver um. Sempre teste seus apps em dispositivos virtuais e físicos.

De que você precisa:

• Um dispositivo Android, como um smartphone ou tablet.
• Um cabo de dados USB para conectar o dispositivo Android ao computador pela porta USB.
• Se você estiver usando um sistema Linux ou Windows, talvez seja necessário seguir outras etapas. Consulte a documentação Executar apps em um dispositivo de hardware. Também pode ser necessário instalar o driver USB adequado para o dispositivo. Para drivers USB baseados no Windows, consulte Instalar drivers USB OEM.

Etapa 1: ativar a depuração USB

Para permitir que o Android Studio se comunique com seu dispositivo Android, ative a depuração USB nas configurações Opções do desenvolvedor do dispositivo.

No Android 4.2 (Jellybean) e versões mais recentes, as configurações Opções do desenvolvedor ficam ocultas por padrão. Para exibir as Opções do desenvolvedor e ativar a depuração USB, faça o seguinte:

1. No dispositivo, abra Configurações, procure Sobre o dispositivo, toque em Sobre o dispositivo e em Número da versão sete vezes.
2. Volte para a página anterior (Configurações / Sistema). As Opções do desenvolvedor vão aparecer na lista. Toque em Opções do desenvolvedor.
3. Selecione Depuração USB.

Etapa 2: executar o app no dispositivo Android

Você já pode conectar o dispositivo e executar o app no Android Studio.

1. Conecte o dispositivo Android à máquina de desenvolvimento com um cabo USB. Uma caixa de diálogo será exibida no dispositivo, permitindo a depuração USB.
   
   
   
2. Selecione a opção Sempre permitir para lembrar deste computador. Toque em OK.
3. No computador, na barra de ferramentas do Android Studio, clique no botão Run . A caixa de diálogo Selecionar destino de implantação será aberta com a lista de emuladores disponíveis e dispositivos conectados. Você vai ver seu dispositivo físico com os emuladores.
   
   
   
4. Selecione seu dispositivo e clique em OK. O Android Studio vai instalar e executar o app no dispositivo.

Solução de problemas

Se o Android Studio não reconhecer o dispositivo, tente o seguinte:

1. Desconecte o cabo USB e conecte-o novamente.
2. Reinicie o Android Studio.

Caso seu computador ainda não reconheça o dispositivo ou o declare como "não autorizado", siga estas etapas:

1. Desconecte o cabo USB.
2. No dispositivo, abra as Opções do desenvolvedor no app Configurações.
3. Toque em Revogar autorizações de depuração USB.
4. Reconecte o dispositivo ao computador.
5. Quando solicitado, conceda as autorizações.

Talvez seja necessário instalar o driver USB adequado para o dispositivo. Consulte Executar apps em um dispositivo de hardware.

Observação:todos os desafios de programação são opcionais.

Desafio : agora que você já configurou tudo e conhece o fluxo de trabalho básico de desenvolvimento, faça o seguinte:

1. Crie um novo projeto no Android Studio.
2. Mude a saudação "Hello World" para "Feliz aniversário para " e o nome de alguém que fez aniversário recentemente.

• Para instalar o Android Studio, acesse Android Studio e siga as instruções para fazer o download e a instalação.
• Para conferir a hierarquia do Android de um app no painel "Projeto", clique na guia Projeto na coluna de guias vertical. Em seguida, selecione Android no menu suspenso na parte de cima.
• Quando precisar adicionar novas dependências ao projeto ou mudar as versões, edite o arquivo build.gradle(Module:app).
• Todo o código e os recursos de um app estão localizados nas pastas app e res. A pasta java inclui atividades, testes e outros componentes em código-fonte Kotlin ou Java (ou ambos). A pasta res contém recursos, como layouts, strings e imagens.
• Para adicionar recursos, componentes e permissões ao seu app Android, edite o arquivo AndroidManifest.xml. Todos os componentes do app, como atividades adicionais, precisam ser declarados nesse arquivo XML.
• Para criar um Dispositivo virtual Android (um emulador) para executar seu app, use o AVD Manager.
• Para executar o app em um dispositivo Android físico usando o Android Studio, ative a depuração USB no dispositivo. Para isso, abra Configurações > Sobre o dispositivo e toque em Número da versão sete vezes. Em seguida, abra Configurações > Opções do desenvolvedor e selecione Depuração USB.

Curso da Udacity:

• Desenvolvimento de apps Android com Kotlin

Documentação do Android Studio:

• Página de download do Android Studio
• Notas da versão do Android Studio
• Conheça o Android Studio
• Criar e gerenciar dispositivos virtuais
• Visão geral do manifesto do app
• Configurar seu build
• Criar e gerenciar dispositivos virtuais

Outro:

• Site do Gradle
• Página do Gradle na Wikipédia (link em inglês)

Esta seção lista as possíveis atividades de dever de casa para os alunos que estão fazendo este codelab como parte de um curso ministrado por um professor. Cabe ao professor fazer o seguinte:

• Atribuir o dever de casa, se necessário.
• Informar aos alunos como enviar deveres de casa.
• Atribuir nota aos deveres de casa.

Os professores podem usar essas sugestões o quanto quiserem, podendo passar os exercícios que acharem mais apropriados como dever de casa.

Se você estiver seguindo este codelab por conta própria, sinta-se à vontade para usar esses deveres de casa para testar seu conhecimento.

Criar e executar um app

• Crie um projeto Android usando o modelo vazio.
• Abra o arquivo res/strings.xml.
• Mude o valor da string app_name para "My Dice Roller". Esse nome aparece na barra de título.
• Crie um emulador para um dispositivo, segmentando qualquer versão do Android que você quiser, e execute o app. Observe como o título do app mudou.

Responda estas perguntas

Pergunta 1

Qual é o nome do arquivo de layout da atividade principal?

• MainActivity.java
• AndroidManifest.xml
• activity_main.xml
• build.gradle

Pergunta 2

Qual é o nome do recurso de string que especifica o nome do app?

• app_name
• xmlns:app
• android:name
• applicationId

Pergunta 3

Qual ferramenta você usa para criar um novo emulador?

• Android Device Monitor
• AVD Manager
• SDK Manager
• Theme Editor

Enviar o app para avaliação

Verifique se o app tem o seguinte:

• Um Activity que mostra "Hello World" na tela.
• Uma barra de título que diz "Meu Dice Roller".

Comece a próxima lição: 1.2: Anatomia básica de um app

Para acessar links de outros codelabs neste curso, consulte a página inicial dos codelabs de conceitos básicos do Kotlin para Android.