Fundamentos de Android em Kotlin 01.1: Primeiros passos

Introdução

Neste tutorial, você cria e executa seu primeiro aplicativo Android, HelloWorld, em um emulador e em um dispositivo físico. Você também explora a aparência de um projeto Android.

O que já deveria saber

Você deve compreender o processo geral de desenvolvimento de software para aplicativos orientados a objetos usando um IDE (ambiente de desenvolvimento integrado) como o Android Studio.
Você deve 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 aprenderá

Como construir um aplicativo Android básico no Android Studio.
Como criar um projeto Android a partir de um modelo.
Como encontrar os principais componentes de um projeto Android.
Como executar um aplicativo Android em um emulador ou dispositivo físico.

O que fará

Crie um projeto Android e um aplicativo padrão chamado HelloWorld.
Crie um emulador (um dispositivo virtual) para que você possa executar seu aplicativo em seu computador.
Execute o aplicativo HelloWorld em dispositivos virtuais e físicos.
Explore o layout do projeto.
Explore o arquivo AndroidManifest.xml.

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

Nesta tarefa, você cria um projeto de aplicativo para verificar se o Android Studio está instalado corretamente.

Abra o Android Studio, se ainda não estiver aberto.
Na caixa de diálogo principal Welcome to Android Studio, clique em Start a new Android Studio project.
A caixa de diálogo Choose your projecté exibida. Selecione Empty Activity conforme mostrado abaixo e clique em Next.

Uma Activity é uma atividade única e focada que o usuário pode fazer. Cada aplicativo deve ter, pelo menos, uma atividade como ponto de entrada. Pense nesta atividade de ponto de entrada como a função main() em outros programas. Uma atividade normalmente tem um layout associado a ela que define como os elementos da interface do usuário (IU) aparecem em uma tela. O Android Studio fornece vários modelos de Activity para ajudá-lo a começar.
Na caixa de diálogo Configure your project, digite "HelloWorld" para o Name.
Aceite o padrão android.example.com para Company domain ou crie um domínio exclusivo da empresa. Este valor mais o nome do aplicativo é o nome do pacote para seu aplicativo. Se você não planeja publicar seu aplicativo, aceite o padrão. Você pode alterar o nome do pacote do seu aplicativo mais tarde, mas é um trabalho extra.
Verifique se o Save location padrão é onde você deseja armazenar seu aplicativo. Caso contrário, mude o local para o diretório de sua preferência.
Certifique-se de que a Language seja Kotlin.
Certifique-se de que o nível mínimo de API seja API 19: Android 4.4 (KitKat). No momento em que este tutorial foi escrito, o Android Studio indicou que, com este nível de API, o aplicativo seria executado em aproximadamente 95,3% dos dispositivos.
(Você aprenderá mais sobre os níveis mínimos de API em um tutorial posterior. Para saber mais agora, clique em Help me choose, que abre uma janela com informações sobre os níveis de API).
Marque a caixa de seleção Use AndroidX artifacts.
Deixe todas as outras caixas de seleção desmarcadas e clique em Finish. Se o seu projeto requer mais componentes para o SDK de destino escolhido, o Android Studio os instala automaticamente, o que pode demorar um pouco. Siga as instruções e aceite as opções padrão.

O Android Studio agora cria seu projeto, o que pode levar algum tempo. Você não deve obter nenhum erro. Se você receber algum aviso, ignore-o.

Nesta tarefa, você explorará o projeto HelloWorld no Android Studio e aprenderá os fundamentos do desenvolvimento com o Android Studio.

Etapa 1: Explore o painel Projeto

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 Projeto é aberto.
Para visualizar o projeto como uma hierarquia de projeto Android padrão, selecione Android no menu suspenso na parte superior do painel Projeto. (Android é o padrão). Você pode visualizar os arquivos do projeto de muitas maneiras diferentes, incluindo a vista dos arquivos como eles aparecem na hierarquia do sistema de arquivos. No entanto, é mais fácil trabalhar com o projeto usando a vista do Android.

Etapa 2: Explore a pasta do aplicativo

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

No painel Project > Android, expanda a pasta app. Dentro da pasta app há quatro subpastas: manifests, java, generatedJava e res.
Expanda a pasta java e, em seguida, expanda a pasta com.example.android.HelloWorld para ver o arquivo MainActivity Kotlin.

A pasta java contém todo o código Kotlin principal para um aplicativo Android. Existem razões históricas pelas quais seu código Kotlin aparece na pasta java. Essa convenção permite que o Kotlin interopere perfeitamente com o código escrito na linguagem de programação Java, mesmo no mesmo projeto e aplicativo.

Os arquivos de classe do seu aplicativo estão contidos em três subpastas, conforme mostrado na figura acima. A pasta com.example.hello.helloworld (ou o nome de domínio que você especificou) contém todos os arquivos de um pacote de aplicativo. Em particular, a classe MainActivity é o principal ponto de entrada para seu aplicativo. Você aprenderá mais sobre MainActivity no próximo tutorial. As outras duas pastas na pasta java são usadas para códigos relacionados a testes, como testes de unidade.

Observe a pasta generatedJava. Esta pasta contém arquivos que o Android Studio gera ao construir o aplicativo. Não edite nada nesta pasta, pois suas alterações podem ser substituídas quando você reconstruir o aplicativo. Mas é útil saber sobre essa pasta quando você precisar examinar esses arquivos durante a depuração.

Etapa 3: Explore a pasta res

No painel Project > Android, expanda a pasta res.

A pasta res contém recursos. Recursos no Android são conteúdo estático usado em seus aplicativos. Os recursos incluem imagens, strings de texto, layouts de tela, estilos e valores como cores hexadecimais ou dimensões padrão.

Os aplicativos Android separam o código Kotlin e os recursos o máximo possível. Isso torna muito mais fácil encontrar todas as strings ou ícones que são usados na IU do aplicativo. Além disso, quando você altera um desses arquivos de recursos, a alteração tem efeito em todos os lugares em que o arquivo é usado no aplicativo.
Na pasta res, expanda a pasta layout para ver o arquivo activity_main.xml.

Sua Activity geralmente está associada a um arquivo de layout de IU, definido como um arquivo XML no diretório res/layout. Esse arquivo de layout geralmente é nomeado de acordo com sua atividade. Neste caso, o nome da atividade é MainActivity, então o layout associado é activity_main.

Etapa 4: Explore a pasta de manifestos e AndroidManifest.xml

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

Expanda a pasta manifests e clique duas vezes em AndroidManifest.xml para abri-la. O arquivo AndroidManifest.xml inclui detalhes que o sistema Android precisa para executar seu aplicativo, incluindo quais atividades fazem parte do aplicativo.
Observe que MainActivity é referenciado no elemento <activity>. Qualquer Activity em seu aplicativo deve ser declarada no manifesto. Aqui está 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>

Observe o elemento <intent-filter> dentro de <activity>. Os elementos <action> e <category> neste filtro de intent informam ao Android onde iniciar o aplicativo quando o usuário clicar no ícone do iniciador. Você aprenderá mais sobre filtros de intent em um tutorial posterior.

O arquivo AndroidManifest.xml também é o lugar onde você definiria as permissões de que seu aplicativo precisava. As permissões incluem a capacidade de seu aplicativo ler contatos telefônicos, enviar dados pela Internet ou acessar hardware, como a câmera do dispositivo.

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

Explore o sistema Gradle:

Expanda a pasta Gradle Scripts. No painel Project > Android, esta pasta contém todos os arquivos que o sistema de compilação precisa.
Procure o arquivo build.gradle(Project: HelloWorld).

Este arquivo contém as opções de configuração que são comuns a todos os módulos que compõem o seu projeto. Cada projeto do Android Studio contém um único arquivo de compilação Gradle de nível superior. Este arquivo define os repositórios e dependências do Gradle que são comuns a todos os módulos do projeto.
Procure o arquivo build.gradle(Module:app).

Além do arquivo build.gradle de nível de projeto, cada módulo tem um arquivo build.gradle próprio. O arquivo build.gradle de nível de módulo permite que você defina as configurações de compilação para cada módulo. (O aplicativo HelloWorld tem apenas um módulo, o módulo para o próprio aplicativo). Este arquivo build.gradle é o que você edita com mais frequência ao alterar as configurações de compilação no nível do aplicativo. Por exemplo, você edita este arquivo build.gradle ao alterar o nível do SDK que seu aplicativo suporta ou ao declarar novas dependências na seção dependencies. Você aprenderá mais sobre esses dois assuntos em um tutorial posterior.

Nesta tarefa, você usa o gerenciador de dispositivo virtual Android (AVD) para criar um dispositivo virtual (um emulador). O dispositivo virtual simula a configuração de um determinado tipo de dispositivo Android. Em seguida, você usa esse dispositivo virtual para executar o aplicativo.

O Android Emulator é um aplicativo independente e possui seus próprios requisitos de sistema. Os dispositivos virtuais podem usar muito espaço em disco. Se você tiver problemas, consulte Executando aplicativos no Android Emulator.

Etapa 1: Crie um dispositivo virtual Android (AVD)

Para executar um emulador em seu computador, você deve criar uma configuração que descreva o dispositivo virtual.

No Android Studio, selecione Tools > AVD Manager ou clique no ícone AVD Manager na snackbar. A caixa de diálogo Your Virtual Devicesé exibida. Se você já criou dispositivos virtuais, a caixa de diálogo os mostra (conforme mostrado na figura abaixo). Caso contrário, você verá uma lista em branco.
Clique em +Create Virtual Device na parte inferior esquerda 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 fornece uma coluna para seu tamanho da tela diagonal (Size), resolução de tela em pixels (Resolution) e densidade de pixels (Density).
Selecione um dispositivo como Nexus 5x ou Pixel XL e clique em Next. A caixa de diálogo System Imageé exibida.
Clique na guia Recommended e escolha qual versão do sistema Android executar no dispositivo virtual (como Pie).

Depois de escolher uma imagem do sistema, clique em Next. A caixa de diálogo Android Virtual Device (AVD) é aberta. Verifique sua configuração e clique em Finish.

Etapa 2: Execute o aplicativo no dispositivo virtual

Nesta tarefa, você finalmente executa seu novo aplicativo.

No Android Studio, selecione Run > Run app ou clique no ícone Run na snackbar. A caixa de diálogo Select Deployment Target aparece e avisa que nenhum dispositivo está disponível. Você verá este aviso se não tiver um dispositivo físico conectado ao computador de desenvolvimento ou se ainda não tiver iniciado um dispositivo virtual.
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, este processo pode demorar um pouco. Seu aplicativo é compilado e, quando o emulador está pronto, o Android Studio carrega o APK do aplicativo no emulador e o executa.

Você deve ver o aplicativo HelloWorld conforme mostrado na figura a seguir.

Nesta tarefa, você executa seu aplicativo em um dispositivo móvel físico, como um telefone ou tablet, se tiver um. Sempre teste seus aplicativos em dispositivos virtuais e físicos.

O que você precisa:

Um dispositivo Android, como um telefone ou tablet.
Um cabo de dados USB para conectar seu dispositivo Android ao computador através da porta USB.
Se você estiver usando um sistema Linux ou Windows, pode ser necessário executar etapas extras. Consulte a documentação Executando aplicativos em um dispositivo de hardware. Também pode ser necessário instalar o driver USB apropriado para o seu dispositivo. Para drivers USB baseados em Windows, consulte Instalando drivers USB OEM.

Etapa 1: Ative a depuração USB

Para permitir que o Android Studio se comunique com seu dispositivo Android, você deve habilitar a depuração USB nas configurações de Developer options do dispositivo.

No Android 4.2 (Jellybean) e superior, as configurações de Developer options estão ocultas por padrão. Para mostrar as opções do desenvolvedor e habilitar a depuração USB:

Em seu dispositivo, abra Settings, pesquise About phone, toque em About phone e toque em Build number sete vezes.
Retorne à página anterior (Settings / System). Developer options aparecem na lista. Toque em Developer options.
Selecione USB debugging.

Etapa 2: Execute seu aplicativo no dispositivo Android

Agora você pode conectar seu dispositivo e executar o aplicativo do Android Studio.

Conecte o dispositivo Android à sua máquina de desenvolvimento com um cabo USB. Uma caixa de diálogo deve aparecer no dispositivo, solicitando a permissão da depuração de USB.
Selecione a opção Always allow para lembrar este computador. Toque em OK.
Em seu computador, na snackbar do Android Studio, clique no botão Run . A caixa de diálogo Select Deployment Target é aberta com a lista de emuladores disponíveis e dispositivos conectados. Você deve ver seu dispositivo físico junto com quaisquer emuladores.
Selecione seu dispositivo e clique em OK. O Android Studio instala o aplicativo em seu dispositivo e o executa.

Solução de problemas

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

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

Se o seu computador ainda não encontrar o dispositivo ou o declarar "não autorizado", siga estas etapas:

Desconecte o cabo USB.
No dispositivo, abra as Developer options no aplicativo Settings.
Toque em Revoke USB debugging authorizations.
Reconecte o dispositivo ao computador.
Quando solicitado, conceda autorizações.

Pode ser necessário instalar o driver USB apropriado para o seu dispositivo. Consulte Executando aplicativos em um dispositivo de hardware.

Desafio: Agora que você está configurado e familiarizado com o fluxo de trabalho de desenvolvimento básico, faça o seguinte:

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

Para instalar o Android Studio, vá para Android Studio e siga as instruções para fazer o download e instalá-lo.
Para ver a hierarquia Android de um aplicativo no painel Projeto, clique na guia Project na coluna da guia vertical. Em seguida, selecione Android no menu suspenso na parte superior.
Quando você precisar adicionar novas dependências ao seu projeto ou alterar as versões das dependências, edite o arquivo build.gradle(Module:app).
Todos os códigos e recursos de um aplicativo estão localizados nas pastas app e res. A pasta java inclui atividades, testes e outros componentes no 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 aplicativo Android, edite o arquivo AndroidManifest.xml. Todos os componentes do aplicativo, como atividades adicionais, devem ser declarados neste arquivo XML.
Para criar um dispositivo virtual Android (um emulador) para executar seu aplicativo, use o AVD Manager.
Para executar seu aplicativo em um dispositivo Android físico usando o Android Studio, ative a depuração USB no dispositivo. Para fazer isso, abra Settings > About phone e toque em Build number sete vezes. Em seguida, abra Settings> Developer options e selecione USB debugging.

Documentação do Android Studio:

De outros:

Site do Gradle

Esta seção lista as possíveis tarefas de casa para os alunos que estão trabalhando neste tutorial como parte de um curso ministrado por um instrutor.

Crie e execute um aplicativo

Crie um projeto Android a partir do modelo vazio.
Abra o arquivo res/strings.xml.
Altere o valor da string app_name para "My Dice Roller". Este nome aparece na barra principal.
Crie um emulador para um dispositivo, visando qualquer versão do Android que você gosta, e execute o aplicativo. Observe como o título do aplicativo mudou.

Responda a essas perguntas

Pergunta 1

Qual é o nome do arquivo de layout para a 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 aplicativo?

app_name
xmlns:app
android:name
applicationId

Pergunta 3

Qual ferramenta você usa para criar um emulador?

Android Device Monitor
AVD Manager
SDK Manager
Theme Editor

Envie seu aplicativo para avaliação

Verifique se o aplicativo tem o seguinte:

Uma Activity que exibe "Hello World" na tela.
Uma barra principal que diz "My Dice Roller".

Comece a próxima lição: 01.2: Anatomia do projeto Android básico

Para obter enlaces para outros tutoriais neste curso, consulte a página de destino dos tutoriais Fundamentos de Android em Kotlin.