Conceitos básicos do Kotlin para Android 01.2: anatomia básica de um app

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

Até agora, você configurou tudo, e o Android Studio criou muito código para você. Antes de modificar todo esse código, é importante saber o que você acabou de criar e como navegar pelos arquivos de origem de um app Android.

Neste codelab, você vai aprender mais sobre os principais componentes de um app Android e adicionar uma interatividade simples a um app com um botão.

O que você já precisa saber

• Como instalar e abrir o Android Studio.
• Como criar um novo projeto de app.
• Como executar um app em um emulador ou dispositivo físico.

O que você vai aprender

• Como editar o arquivo de layout do app.
• Como criar um app com comportamento interativo.
• Muitas tecnologias novas. Confira o glossário de vocabulário para explicações simples de termos e conceitos.

Atividades do laboratório

• Explore o arquivo Kotlin MainActivity e o arquivo de layout da atividade.
• Edite o layout da atividade em XML.
• Adicione um elemento Button ao layout da atividade.
• Extraia strings codificadas em um arquivo de recursos de string.
• Implemente métodos de processamento de cliques para mostrar mensagens na tela quando o usuário tocar em um Button.

Neste codelab, você vai criar um novo projeto de app chamado DiceRoller e adicionar interatividade básica com um botão. Toda vez que o botão é clicado, o valor do texto exibido muda. O app DiceRoller final deste codelab vai ficar assim:

No último codelab, você aprendeu sobre as principais partes de um projeto de app, incluindo os diretórios java e res. Nesta tarefa, você vai se concentrar nos dois arquivos mais importantes que compõem seu app: o arquivo Kotlin MainActivity e o arquivo de layout activity_main.xml.

Etapa 1: examine a MainActivity

MainActivity é um exemplo de Activity. Uma Activity é uma classe principal do Android que desenha uma interface do usuário (IU) de um app Android e recebe eventos de entrada. Quando o app é iniciado, ele inicia a atividade especificada no arquivo AndroidManifest.xml.

Muitas linguagens de programação definem um método principal que inicia o programa. Os apps Android não têm um método principal. Em vez disso, o arquivo AndroidManifest.xml indica que MainActivity deve ser iniciado quando o usuário tocar no ícone do app na tela de início. Para iniciar uma atividade, o SO Android usa as informações no manifesto para configurar o ambiente do app e construir a MainActivity. Em seguida, o MainActivity faz algumas configurações.

Cada atividade tem um arquivo de layout associado. A atividade e o layout são conectados por um processo conhecido como inflação de layout. Quando a atividade é iniciada, as visualizações definidas nos arquivos de layout XML são transformadas (ou "infladas") em objetos de visualização Kotlin na memória. Quando isso acontece, a atividade pode desenhar esses objetos na tela e também modificá-los de forma dinâmica.

1. No Android Studio, selecione File > New > New Project para criar um projeto. Use a atividade vazia e clique em Próxima.
2. Chame o projeto de DiceRoller e verifique todos os outros valores de nome e local do projeto. Confira se a opção "Usar artefatos do AndroidX" está marcada. Clique em Concluir.
   
   
   
3. No painel Project > Android, clique para expandir java > com.example.android.diceroller. Clique duas vezes em MainActivity. O editor de código mostra o código em MainActivity.
   
   
   
4. Abaixo do nome do pacote e das instruções de importação está a declaração da classe para MainActivity. A classe MainActivity estende AppCompatActivity.

class MainActivity : AppCompatActivity() { ...

AppCompatActivity é uma subclasse de Activity que oferece suporte a todos os recursos modernos do Android e compatibilidade com versões anteriores do SO. Para disponibilizar o app para o maior número possível de dispositivos e usuários, sempre use AppCompatActivity.

5. Observe o método onCreate(). As atividades não usam um construtor para inicializar o objeto. Em vez disso, uma série de métodos predefinidos (chamados de "métodos de ciclo de vida") são chamados como parte da configuração da atividade. Um desses métodos de ciclo de vida é onCreate(), que você sempre substitui no seu próprio app. Você vai aprender mais sobre os métodos de ciclo de vida em um codelab posterior.
   
   Em onCreate(), você especifica qual layout está associado à atividade e o infla. O método setContentView() faz as duas coisas.
   

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   setContentView(R.layout.activity_main)
}

O método setContentView() faz referência ao layout usando R.layout.activity_main, que é uma referência de número inteiro. A classe R é gerada quando você cria o app. Ela inclui todos os recursos do app, incluindo o conteúdo do diretório res.R

Nesse caso, R.layout.activity_main se refere à classe R gerada, à pasta layout e ao arquivo de layout activity_main.xml. Os recursos não incluem extensões de arquivo. Você vai se referir a muitos dos recursos do app (incluindo imagens, strings e elementos no arquivo de layout) usando referências semelhantes na classe R.

Etapa 2: analisar e explorar o arquivo de layout do app

Todas as atividades no seu app têm um arquivo de layout associado no diretório res/layout do app. Um arquivo de layout é um arquivo XML que expressa a aparência de uma atividade. Um arquivo de layout faz isso definindo visualizações e onde elas aparecem na tela.

Views são elementos como texto, imagens e botões que estendem a classe View. Há muitos tipos de visualizações, incluindo TextView, Button, ImageView e CheckBox.

Nesta tarefa, você vai examinar e modificar o arquivo de layout do app.

1. No painel Project > Android, expanda res > layout e clique duas vezes em activity_main.xml. O editor de design de layout será aberto. O Android Studio inclui esse editor, que permite criar o layout do app de maneira visual e visualizar o design. Você vai aprender mais sobre o editor de design em um próximo codelab.
2. Para ver o arquivo de layout como XML, clique na guia Text na parte de baixo da janela.
   
   
   
3. Exclua todo o código XML no editor de layout. O layout padrão que você recebe com um novo projeto é um bom ponto de partida se estiver trabalhando com o editor de design do Android Studio. Nesta lição, você vai trabalhar com o XML subjacente para criar um novo layout do zero.
4. Copie e cole este código no layout:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout   
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    tools:context=".MainActivity" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />

</LinearLayout>

Agora examine o código:

1. O elemento raiz ou de nível superior do layout é um elemento <LinearLayout>. A visualização LinearLayout é um ViewGroup. Os grupos de visualizações são contêineres que contêm outras visualizações e ajudam a especificar as posições delas na tela.
   
   Todas as visualizações e grupos de visualizações adicionados ao layout são organizados em uma hierarquia de visualizações, com o elemento XML mais alto como raiz dessa hierarquia. A visualização raiz pode conter outras visualizações e grupos de visualizações, e os grupos de visualizações contidos podem conter outras visualizações e grupos de visualizações. Quando o app executa a hierarquia de visualizações no arquivo de layout XML, ela se torna uma hierarquia de objetos quando o layout é inflado. Nesse caso, o grupo de visualizações raiz é um layout linear, que organiza as visualizações filhas de forma linear, uma após a outra (vertical ou horizontalmente).
   
   A raiz padrão de um novo projeto do Android é um ConstraintLayout, que funciona bem em coordenação com o editor de design. Para esse app, você vai usar um grupo de visualização LinearLayout, que é mais simples do que o layout de restrição. Você vai aprender muito mais sobre grupos de visualização e layout restrito na próxima lição.
2. Dentro da tag LinearLayout, observe o atributo android:layout_width. A largura desse LinearLayout é definida como match parent, o que faz com que ele tenha a mesma largura do elemento pai. Como essa é a visualização raiz, o layout se expande para a largura total da tela.
3. Observe o atributo android:layout_height, que está definido como wrap_content. Esse atributo faz com que a altura da LinearLayout corresponda à altura combinada de todas as visualizações que ela contém, que por enquanto é apenas a TextView.
4. Examine o elemento <TextView>. Essa TextView, que mostra texto, é o único elemento visual no app DiceRoller. O atributo android:text contém a string real a ser mostrada, nesse caso, a string "Hello World!".
5. Observe os atributos android:layout_width e android:layout_height no elemento <TextView>, que estão definidos como wrap_content. O conteúdo da visualização de texto é o próprio texto. Portanto, a visualização ocupa apenas o espaço necessário para o texto.

O app de jogar dados não é muito útil sem uma maneira de o usuário jogar os dados e ver o resultado. Para começar, adicione um botão ao layout para rolar os dados e adicione um texto que mostre o valor que o usuário tirou.

Etapa 1: adicionar um botão ao layout

1. Adicione um elemento Button ao layout abaixo da visualização de texto inserindo <Button e pressionando Return. Um bloco Button aparece, terminando com /> e incluindo os atributos layout_width e layout_height.

<Button
   android:layout_width=""
   android:layout_height="" />

2. Defina os atributos layout_width e layout_height como "wrap_content". Com esses valores, o botão tem a mesma largura e altura do rótulo de texto que ele contém.
3. Adicione um atributo android:text ao botão e atribua a ele o valor "Roll". O elemento "Button" agora fica assim:

<Button
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:text="Roll" />

Para visualizações Button, o atributo text é o rótulo do botão. No editor de layout, o atributo é destacado em amarelo, o que indica uma dica ou um aviso. Nesse caso, o destaque em amarelo ocorre porque a string "Roll" está codificada no rótulo do botão, mas ela deveria ser um recurso. Você vai aprender sobre recursos de string na próxima seção.

Etapa 2: extrair recursos de string

Em vez de fixar strings nos arquivos de layout ou código, a prática recomendada é colocar todas as strings do app em um arquivo separado. Esse arquivo é chamado strings.xml e fica localizado entre os recursos do app, no diretório res/values/.

Ter as strings em um arquivo separado facilita o gerenciamento delas, principalmente se você as usar mais de uma vez. Além disso, os recursos de string são obrigatórios para traduzir e localizar seu app, porque é necessário criar um arquivo de recursos de string para cada idioma.

O Android Studio ajuda você a lembrar de colocar as strings em um arquivo de recursos com dicas e alertas.

1. Clique uma vez na string "Roll" no atributo android:text da tag <Button>.
2. Pressione Alt+Enter (Option+Enter no macOS) e selecione Extrair recurso de string no menu pop-up.
3. Insira roll_label no campo Nome do recurso.
4. Clique em OK. Um recurso de string é criado no arquivo res/values/string.xml, e a string no elemento "Button" é substituída por uma referência a esse recurso:
   android:text="@string/roll_label"
5. No painel Project > Android, expanda res > values e clique duas vezes em strings.xml para ver os recursos de string no arquivo strings.xml:

<resources>
   <string name="app_name">DiceRoller</string>
   <string name="roll_label">Roll</string>
</resources>

Dica: além da string que você acabou de adicionar, o arquivo strings.xml também inclui o nome do app. O nome do app aparece na barra de apps na parte de cima da tela se você iniciar o projeto do app usando o modelo vazio. Para mudar o nome do app, edite o recurso app_name.

Etapa 3: estilizar e posicionar visualizações

Seu layout agora contém uma visualização TextView e uma Button. Nesta tarefa, você vai organizar as visualizações dentro do grupo para que fiquem mais atraentes.

1. Clique na guia Design para conferir uma prévia do layout. No momento, as duas visualizações estão lado a lado e empurradas para a parte de cima da tela.
   
   
   
2. Clique na guia Texto para voltar ao editor XML. Adicione o atributo android:orientation à tag LinearLayout e atribua a ele o valor "vertical". O elemento <LinearLayout> vai ficar assim:

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   tools:context=".MainActivity">

O grupo de visualizações LinearLayout posiciona as visualizações que ele contém uma após a outra em uma linha, horizontalmente em uma linha ou verticalmente em uma pilha. O padrão é horizontal. Como você quer que a TextView fique acima da Button, defina a orientação como vertical. O design agora fica assim, com o botão abaixo do texto:

3. Adicione o atributo android:layout_gravity aos elementos TextView e Button e atribua a ele o valor "center_horizontal". Isso alinha as duas visualizações ao longo do centro do eixo horizontal. Os elementos TextView e Button vão ficar assim:

<TextView   
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="Hello World!" />

<Button
   android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:text="@string/roll_label" />

4. Adicione o atributo android:layout_gravity ao layout linear e atribua a ele o valor "center_vertical". O elemento LinearLayout vai ficar assim:

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   android:layout_gravity="center_vertical"
   tools:context=".MainActivity">

Observação : se você adicionar a gravidade center_vertical ao botão e às visualizações de texto (em vez de center_horizontal), as visualizações serão centralizadas horizontal e verticalmente no meio do layout. Ou seja, as visualizações ficam uma em cima da outra.

Para centralizar todos os elementos filhos de uma vez, use center_vertical no elemento pai (o elemento LinearLayout), como mostrado acima.

5. Para aumentar o tamanho do texto na visualização de texto, adicione o atributo android:textSize ao elemento <TextView> com o valor "30sp". A abreviação sp significa pixels escalonáveis, que é uma medida para dimensionar o texto independente da qualidade de exibição do dispositivo. O elemento TextView vai ficar assim:

<TextView   
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:textSize="30sp"
   android:text="Hello World!" />

6. Compile e execute o app.
   
   
   

Agora, o texto e o botão estão bem posicionados, e há um texto maior na visualização de texto. O botão ainda não tem nenhuma funcionalidade, então nada acontece quando você clica nele. Você vai trabalhar nisso em seguida.

Etapa 4: receber uma referência ao botão no código

O código Kotlin em MainActivity é responsável por definir as partes interativas do app, como o que acontece quando você toca em um botão. Para escrever uma função que seja executada quando o botão for clicado, você precisa receber uma referência ao objeto Button no layout inflado em MainActivity. Para receber uma referência ao botão:

• Atribua um ID ao Button no arquivo XML.
• Use o método findViewById() no código para receber uma referência ao View com um ID específico.

Depois de ter uma referência à visualização Button, você pode chamar métodos nessa visualização para mudá-la dinamicamente à medida que o app é executado. Por exemplo, você pode adicionar um gerenciador de cliques que executa o código quando o botão é tocado.

1. Abra o arquivo de layout activity_main.xml, se ele ainda não estiver aberto, e clique na guia Texto.
2. Adicione o atributo android:id ao botão e dê um nome a ele (neste caso, "@+id/roll_button""). Agora, o elemento <Button> tem esta aparência:

<Button
   android:id="@+id/roll_button"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:text="@string/roll_label" />

Quando você cria um ID para uma visualização no arquivo de layout XML, o Android Studio cria uma constante inteira com o nome desse ID na classe R gerada. Assim, se você nomear uma visualização como roll_button, o Android Studio vai gerar e criar uma constante de número inteiro chamada roll_button na classe R. O prefixo "@+id" para o nome do ID informa ao compilador que adicione essa constante de ID à classe R. Todos os IDs de visualização no arquivo XML precisam ter esse prefixo.

3. Abra o arquivo MainActivity Kotlin. Em onCreate(), depois de setContentView(), adicione esta linha:

val rollButton: Button = findViewById(R.id.roll_button)

Use o método findViewById() para receber uma referência View da visualização definida na classe XML. Nesse caso, você recebe a referência Button da classe R e do ID roll_button, e atribui essa referência à variável rollButton.

Observação:se você digitar a linha em vez de copiar e colar, vai notar que o Android Studio oferece uma dica de preenchimento automático para o nome do ID assim que você começar a digitar.

4. O Android Studio destaca a classe Button em vermelho e a sublinha para indicar que é uma referência não resolvida e que você precisa importar essa classe antes de usá-la. Uma dica indicando o nome da classe totalmente qualificado também pode aparecer:
   
   
   
5. Pressione Alt+Enter (Option+Enter em um Mac) para aceitar o nome de classe totalmente qualificado.

Dica: você pode configurar o Android Studio para adicionar automaticamente instruções de importação para classes se o significado for claro. O painel de configurações em Editor > General > Auto Import especifica como as importações são processadas.

Etapa 5: adicionar um gerenciador de cliques para mostrar um toast

Um processador de cliques é um método invocado sempre que o usuário clica ou toca em um elemento da interface clicável, como um botão. Para criar um gerenciador de cliques, você precisa:

• Um método que realiza alguma operação.
• O método setOnClickHandler(), que conecta o Button ao método de manipulador.

Nesta tarefa, você vai criar um método de processador de cliques para mostrar uma Toast. Um aviso é uma mensagem que aparece na tela por um curto período. Você conecta o método de gerenciador de cliques ao Button.

1. Na classe MainActivity, depois de onCreate(), crie uma função particular chamada rollDice().

private fun rollDice() {
  
}

2. Adicione esta linha ao método rollDice() para mostrar uma Toast quando rollDice() for chamado:

Toast.makeText(this, "button clicked", 
   Toast.LENGTH_SHORT).show()

Para criar um toast, chame o método Toast.makeText(). Esse método requer três coisas:

• Um objeto Context. O objeto Context permite que você se comunique e receba informações sobre o estado atual do SO Android. Você precisa de um Context aqui para que o objeto Toast possa informar ao SO para mostrar o toast. Como AppCompatActivity é uma subclasse de Context, basta usar a palavra-chave this para o contexto.
• A mensagem a ser mostrada, aqui "button clicked".
• a duração da exibição da mensagem. O método show() no final mostra o aviso.

3. Em onCreate(), depois da chamada para findViewById(), adicione esta linha para atribuir rollDice() como um manipulador de cliques ao objeto rollButton:

rollButton.setOnClickListener { rollDice() }

A definição completa da classe MainActivity agora fica assim:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val rollButton: Button = findViewById(R.id.roll_button)
        rollButton.setOnClickListener { rollDice() }
    }

    private fun rollDice() {
        Toast.makeText(this, "button clicked",
            Toast.LENGTH_SHORT).show()
    }
}

4. Compile e execute o app. Cada vez que você tocar no botão, uma mensagem vai aparecer.

Nesta tarefa, você vai modificar o método rollDice() para mudar o texto no TextView. Na primeira etapa, mude o texto de "Hello World!" para a string "Dice Rolled!". Na segunda etapa, mostre um número aleatório entre um e seis.

Etapa 1: mostrar uma string

1. Abra activity_main.xml e adicione um ID ao TextView.

android:id="@+id/result_text"

2. Abra MainActivity. No método rollDice(), use um comentário para excluir a linha que mostra a Toast.
3. Use o método findViewById() para receber uma referência ao TextView pelo ID. Atribua a referência a uma variável resultText.

val resultText: TextView = findViewById(R.id.result_text)

4. Atribua uma nova string à propriedade resultText.text para mudar o texto exibido. Ignore a dica para extrair essa string em um recurso. Ela é apenas temporária.

resultText.text = "Dice Rolled!"

5. Compile e execute o app. Toque no botão Jogar para atualizar o TextView.

Etapa 2: mostrar um número aleatório

Por fim, nesta tarefa, você vai adicionar aleatoriedade ao clique do botão para simular o lançamento dos dados. Toda vez que o botão é clicado ou tocado, seu código escolhe um número aleatório de 1 a 6 e atualiza o TextView. A tarefa de gerar um número aleatório não é específica do Android, e você usa a classe Random para fazer isso.

1. Na parte de cima do método rollDice(), use o método Random.nextInt() para receber um número aleatório entre 1 e 6:

val randomInt = Random().nextInt(6) + 1

2. Defina a propriedade text com o valor do número inteiro aleatório, como uma string:

resultText.text = randomInt.toString()

3. Compile e execute o app. Cada vez que você tocar no botão Jogar, o número na visualização de texto vai mudar.

Projeto do Android Studio: DiceRoller (link em inglês)

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

Desafio:adicione um segundo botão ao app chamado "Contar", que aparece logo abaixo do botão Jogar. Ao tocar, o botão Count Up precisa receber o valor atual da visualização de texto do resultado, adicionar 1 a ele e atualizar a visualização de texto. Trate estes casos extremos:

• Se a visualização de texto do resultado ainda não tiver um número (ou seja, se ela ainda tiver a string padrão "Hello World"), defina o texto do resultado como 1.
• Se o número já for 6, não faça nada.

Dica: a string nas visualizações TextView é uma instância da classe CharSequence. Para testar o valor, é necessário convertê-lo em uma string:

resultText.text.toString()

Código da solução do desafio de programação

Projeto do Android Studio: DiceRoller-challenge (link em inglês)

Atividades

• MainActivity é uma subclasse de AppCompatActivity, que, por sua vez, é uma subclasse de Activity. Um Activity é uma classe principal do Android responsável por desenhar uma interface de app Android e receber eventos de entrada.
• Todas as atividades têm um arquivo de layout associado, que é um arquivo XML nos recursos do app. O arquivo de layout recebe o nome da atividade, por exemplo, activity_main.xml.
• O método setContentView() em MainActivity associa o layout à atividade e o infla quando a atividade é criada.
• A inclusão de layout é um processo em que as visualizações definidas nos arquivos de layout XML são transformadas (ou "incluídas") em objetos de visualização Kotlin na memória. Depois que o layout é inflado, o Activity pode desenhar esses objetos na tela e modificá-los de forma dinâmica.

Visualizações

• Todos os elementos da interface no layout do app são subclasses da classe View e são chamados de visualizações. TextView e Button são exemplos de visualizações.
• Os elementos View podem ser agrupados em um ViewGroup. Um grupo de visualizações funciona como um contêiner para as visualizações ou outros grupos de visualizações dentro dele. LinearLayout é um exemplo de grupo de visualizações que organiza as visualizações de forma linear.

Ver atributos

• Os atributos android:layout_width e android:layout_height indicam o peso e a altura de uma visualização. O valor match_parent estica a visualização até a largura ou altura do elemento pai. O valor wrap_content reduz a visualização para ajustar o conteúdo dela.
• O atributo android:text indica o texto que uma visualização precisa mostrar (se ela mostrar texto). Para botões, android:text é o rótulo do botão.
• O atributo android:orientation em um grupo de visualização LinearLayout organiza os elementos de visualização que ele contém. Um valor de horizontal organiza as visualizações da esquerda para a direita. Um valor de vertical organiza as visualizações de cima para baixo.
• O atributo android:layout_gravity determina o posicionamento de uma visualização e de todos os filhos dela.
• O atributo android:textSize define o tamanho do texto em uma visualização de texto. Os tamanhos de texto são especificados em unidades sp (pixels escalonáveis). Ao usar unidades sp, é possível dimensionar o texto independentemente da qualidade da tela do dispositivo.

Strings

• Em vez de fixar strings no layout, a prática recomendada é usar recursos de string.
• Os recursos de string estão contidos no arquivo values/res/string.xml.
• Para extrair strings, use Alt+Enter (Option+Enter em um Mac). Selecione Extrair recursos de string no menu pop-up.

Como usar visualizações

• Para conectar seu código Kotlin a uma visualização definida no layout, você precisa receber uma referência ao objeto de visualização depois que ela for inflada. Atribua um ID (android:id) à visualização no layout e use o método findViewById() para receber o objeto de visualização associado.
• Quando você cria um ID para uma visualização no arquivo de layout XML, o Android Studio cria uma constante inteira com o nome desse ID na classe R gerada. Em seguida, use essa referência R.id no método findViewById().
• É possível definir os atributos de um objeto de visualização no código Kotlin diretamente pelo nome da propriedade. Por exemplo, o texto em uma visualização de texto é definido pelo atributo android:text no XML e pela propriedade text em Kotlin.
• Um processador de cliques é um método invocado quando o usuário clica ou toca em um elemento da interface. Para anexar um método de manipulador de cliques a uma visualização, como um botão, use o método setOnClickListener().

Como usar notificações temporárias

Um aviso é uma visualização que mostra ao usuário uma mensagem simples em uma pequena janela pop-up.

Para criar um toast, chame o método de fábrica makeText() na classe Toast com três argumentos:

• O contexto do app Activity
• A mensagem a ser exibida, por exemplo, um recurso de string
• Uma duração, por exemplo, Toast.LENGTH_SHORT

Para mostrar o aviso, chame show().

Curso da Udacity:

• Desenvolvimento de apps Android com Kotlin

Documentação do desenvolvedor Android:

• Conheça o Android Studio
• Layouts
• View
• Button
• TextView
• Visão geral dos recursos de app
• Visão geral dos eventos de entrada
• findViewById()
• setOnClickListener()
• Context

Outro:

• Glossário de palavras e conceitos de vocabulário

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.

Mudar um app

Abra o app DiceRoller. Adicione um botão com o rótulo "Reset" (Redefinir) que aparece logo abaixo do botão Roll (Jogar). Faça com que esse botão redefina a visualização de texto do resultado para 0.

Responda estas perguntas

Pergunta 1

Qual método em uma Activity infla o layout do app e disponibiliza as visualizações como objetos?

• onCreate()
• setClickListener()
• setContentView()
• show()

Pergunta 2

Que atributo de visualização você usa para definir a largura de uma visualização de modo que ela se ajuste ao conteúdo?

• android:view_width="wrap"
• android:layout_width="wrap_content"
• android:layout_height="wrap_content"
• android:layout_width="match_parent"

Enviar o app para avaliação

Verifique se o app tem o seguinte:

• O layout do app precisa incluir uma visualização de texto e dois botões.
• O código do app precisa definir dois gerenciadores de cliques, um para cada botão.
• O manipulador de cliques que redefine a visualização de texto precisa definir a propriedade de texto como 0.

Comece a próxima lição: 1.3 Recursos de imagem e compatibilidade

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