Conceitos básicos do Kotlin para Android 01.1: primeiros passos

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

Introdução

Neste codelab, você criará e executará seu primeiro app Android, o HelloWorld, em um emulador e em um dispositivo físico. Você também verá a aparência de 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.
• Você precisa ter pelo menos um ano de experiência com programação orientada a objetos e conhecimento de Java e Kotlin.

O que você 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 novo projeto Android e um app padrão chamado HelloWorld.
• Crie um emulador (um dispositivo virtual) para executar o app no computador.
• Execute o app HelloWorld em dispositivos virtuais e físicos.
• Explore o layout do projeto.
• Explore o arquivo AndroidManifest.xml.

O app HelloWorld exibe a string "Hello World" na tela de um dispositivo virtual Android ou dispositivo físico. Veja como o app fica:

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

1. Abra o Android Studio, caso ele ainda não esteja aberto.
2. Na caixa de diálogo Welcome to Android Studio clique em Start a new Android Studio project.
   
   
3. A caixa de diálogo Choose your project é exibida. Selecione Empty Activity conforme mostrado abaixo e clique em Next.
   
   
   
   Uma Activity é uma coisa única e focada que o usuário pode fazer. Cada app precisa ter pelo menos uma atividade como ponto de entrada. Considere essa 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 (IU) aparecem em uma tela. O Android Studio oferece vários modelos de Activity para ajudar você a começar.
   
4. Na caixa de diálogo Configure your project, digite "HelloWorld" em Name.
   
   
5. Aceite o android.example.com padrão para o domínio da empresa ou crie um domínio da empresa exclusivo. O valor mais o nome do app é o nome do pacote do app. Se você não planeja publicá-lo, aceite o padrão. Você pode mudar o nome do pacote do app mais tarde, mas isso é um trabalho extra.
6. Verifique se o padrão para Salvar local é onde você quer armazenar o app. Se não for, mude o local para o diretório que preferir.
7. Confira se a linguagem está em Kotlin.
8. Verifique se o nível mínimo da API é API 19: Android 4.4 (KitKat). No momento 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ê aprenderá mais sobre os níveis mínimos de API em um codelab posterior. Para saber mais, clique em Help me choose, que abre uma janela com informações sobre os níveis de API.
   
9. Marque a caixa de seleção Use AndroidX artifacts.
10. Deixe todas as outras caixas de seleção desmarcadas e clique em Concluir. Se o projeto precisar de mais componentes para o SDK de destino escolhido, o Android Studio os instalará automaticamente, o que pode demorar um pouco. Siga as instruções e aceite as opções padrão.

O Android Studio criará seu projeto, o que pode levar algum tempo. Você não receberá erros. Ignore os alertas que forem exibidos.

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

Etapa 1: explorar o painel "Project"

1. Se a guia Project ainda não estiver selecionada, selecione-a. A guia Project está na coluna da guia vertical no lado esquerdo da janela do Android Studio. O painel "Project" é aberto.
   
   
   
2. Para ver o projeto como uma hierarquia de projetos padrão do Android, selecione Android no menu suspenso na parte superior do painel "Project". O padrão é Android. Você pode ver os arquivos do projeto de várias maneiras, inclusive 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 codelab e outros se referem ao painel do projeto, quando definido como Android, como o painel Project > Android.

Etapa 2: explorar a pasta do app

Todos os recursos e códigos do app estão localizados na pasta app.

1. No painel Project > Android, expanda a pasta app. Na 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. Existem motivos históricos para seu código Kotlin aparecer na pasta Java. Essa convenção permite que o Kotlin interopere facilmente 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 apps. Mais especificamente, a classe MainActivity é o ponto de entrada principal do app. Você aprenderá mais sobre o MainActivity no próximo codelab. As outras duas pastas na pasta java são usadas para códigos relacionados a testes, como testes de unidade.

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

3. Anote a pasta generatedJava. Esta pasta contém arquivos que o Android Studio gera ao criar o app. Não edite nada nela, porque suas alterações podem ser modificadas quando você recria o app. No entanto, é útil saber sobre a pasta quando você precisa analisá-los durante a depuração.

Etapa 3: analisar a pasta "res"

1. No painel Project > Android, expanda a pasta res.
   
   A pasta res contém recursos. Os recursos do Android são conteúdos estáticos usados nos seus 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 os códigos e recursos Kotlin o máximo possível. Assim, fica muito mais fácil encontrar todas as strings ou ícones usados na IU do app. Além disso, quando você altera um desses arquivos de recursos, a alteração entra em vigor em todos os lugares em que o arquivo é usado no app.
2. Na pasta res, expanda a pasta layout para ver o arquivo activity_main.xml.
   
   
   

O Activity geralmente é associado a um arquivo de layout da IU, definido como um arquivo XML no diretório res/layout. Esse arquivo de layout geralmente tem o nome da atividade. Nesse caso, o nome da atividade é MainActivity. Portanto, o layout associado é activity_main.

Etapa 4: explorar a pasta de manifestos e o AndroidManifest.xml

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

1. Expanda a pasta manifests e clique duas vezes em AndroidManifest.xml para abri-la. O arquivo AndroidManifest.xml inclui detalhes de que o sistema Android precisa para executar seu app, incluindo quais atividades fazem parte dele.
   
   
   
2. Observe que MainActivity é referenciado no elemento <activity>. Qualquer Activity no seu app precisa ser declarada no manifesto. Veja um exemplo de 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> desse filtro de intent informam ao Android onde iniciar o app quando o usuário clica no ícone na tela de início. Você aprenderá mais sobre filtros de intent em um codelab posterior.

O arquivo AndroidManifest.xml também é onde você define todas 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 compilação 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 verá informações sobre o Android Package Kit (APK) instalado. O APK é o formato de arquivo de pacote que o sistema operacional Android usa para distribuir e instalar apps para dispositivos móveis.

Explore 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 compilação.
   
   
   
2. Procure o arquivo build.gradle(Project: HelloWorld).
   
   Esse arquivo contém as opções de configuração comuns a todos os módulos que compõem o projeto. Cada projeto do Android Studio contém um único arquivo de compilação do Gradle de nível superior. Esse arquivo define os repositórios e 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 para envolvidos no projeto, cada módulo tem um arquivo build.gradle. O arquivo build.gradle de módulo permite definir configurações de compilação para cada módulo. O app HelloWorld tem apenas um módulo, o módulo do app em si. Esse arquivo build.gradle é aquele que você edita com mais frequência ao alterar configurações de compilação no nível do app. Por exemplo, você pode editar esse arquivo build.gradle ao mudar o nível do SDK compatível com o app ou quando declarar novas dependências na seção dependencies. Você aprenderá mais sobre esses dois pontos em um codelab posterior.

Nesta tarefa, você 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 e tem 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, é necessário 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 será exibida. Se você já tiver criado dispositivos virtuais, a caixa de diálogo os mostrará (como mostrado na figura abaixo). Caso contrário, você verá uma lista em branco.
   
   
   
2. Clique em +Create Virtual Device no canto inferior esquerdo da caixa de diálogo. A caixa de diálogo Select Hardware é exibida, mostrando uma lista de dispositivos de hardware pré-configurados. Para cada dispositivo, a tabela tem uma coluna para o tamanho diagonal da exibição (Size), a resolução da tela em pixels (Resolution) e a densidade de pixels (Density).
   
   
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 para executar no dispositivo virtual (como Pie).
   
   
   

Observação: muitas versões do sistema Android estão disponíveis em mais 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 da imagem do sistema que você quer usar, ela não está instalada. Clique no link para iniciar o download. 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 Android Virtual Device (AVD) será aberta. Verifique sua configuração e clique em Finish.

Etapa 2: executar o app no dispositivo virtual

Nesta tarefa, você executará o novo app.

1. No Android Studio, selecione Run > Run app ou clique no ícone Run na barra de ferramentas. A caixa de diálogo Select Deployment Target será exibida e avisará que nenhum dispositivo está disponível. Você verá esse aviso se 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 Select Deployment Target, em Available Virtual Devices, selecione o dispositivo virtual que você criou. Clique em OK.
   
   
   
   O emulador é iniciado e inicializado como um dispositivo físico. Dependendo da velocidade do seu computador, esse processo pode demorar um pouco. O app será criado e, quando o emulador estiver pronto, o Android Studio fará upload do APK do app para o emulador e o executará.
   
   Você verá o app HelloWorld, como mostra a figura a seguir.
   
   

Nesta tarefa, você executará seu 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.

Pré-requisitos:

• 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 precise realizar etapas extras. Consulte a documentação Executar apps em um dispositivo de hardware. Talvez seja necessário instalar o driver USB adequado para o dispositivo. Para drivers USB baseados em 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 ver as Opções do desenvolvedor e ativar a depuração USB, faça o seguinte:

1. No dispositivo, abra Configurações, pesquise Sobre o dispositivo, toque em Sobre o dispositivo e toque em Número da versão sete vezes.
2. Volte para a página anterior (Configurações / Sistema). As Opções do desenvolvedor aparecem 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 Select Deployment Target será aberta com a lista de emuladores disponíveis e dispositivos conectados. Você 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.

Solucionar 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 o computador ainda não encontre o dispositivo ou o declare como "não autorizado", siga estas etapas:

1. Desconecte o cabo USB.
2. No dispositivo, abra 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á sabe usar o fluxo de trabalho básico de desenvolvimento, faça o seguinte:

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

• Para instalar o Android Studio, acesse o Android Studio e siga as instruções para fazer o download e instalá-lo.
• Para ver a hierarquia do Android de um app no painel "Projeto", clique na guia Projeto na coluna da guia vertical. Em seguida, selecione Android no menu suspenso na parte superior.
• Quando você precisar adicionar novas dependências ao projeto ou mudar as versões de dependência, edite o arquivo build.gradle(Module:app).
• Todos os códigos e recursos de um app estão localizados nas pastas app e res. A pasta java inclui atividades, testes e outros componentes no código-fonte do Kotlin ou Java (ou ambos). A pasta res contém recursos, como layouts, strings e imagens.
• Para adicionar recursos, componentes e permissões ao 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 fazer isso, abra Configurações > Sobre o dispositivo e toque em Número da versão sete vezes. Em seguida, abra Settings > Developer options e selecione USB debugging.

Curso da Udacity:

• Como desenvolver apps Android com Kotlin (link em inglês)

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 (link em inglês)
• Página da Wikipédia sobre o Gradle

Esta seção lista as possíveis atividades para os alunos que estão trabalhando neste codelab como parte de um curso ministrado por um instrutor. Cabe ao instrutor fazer o seguinte:

• Se necessário, atribua o dever de casa.
• Informe aos alunos como enviar o dever de casa.
• Atribua nota aos trabalhos de casa.

Os professores podem usar essas sugestões o quanto quiserem, e eles devem se sentir à vontade para passar o dever de casa como achar adequado.

Se você estiver fazendo este codelab por conta própria, use essas atividades para testar seu conhecimento.

Criar e executar um app

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

Responda a 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 da string que especifica o nome do app?

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

Pergunta 3

Qual ferramenta é usada 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:

• Uma Activity que exibe "Hello World" na tela.
• Uma barra de título com a mensagem "My Dice Roller".

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

Para ver links de outros codelabs neste curso, consulte a página de destino dos codelabs do curso Conceitos básicos do Kotlin para Android.