Atividades e intents

1. Introdução

Até agora, os apps com os quais você trabalhou tiveram apenas uma atividade. Na realidade, muitos apps Android exigem várias atividades, com navegação entre elas.

Neste codelab, você vai criar um app de dicionário que usa várias atividades e intents para navegar entre elas, além de transmitir dados para outros apps.

Pré-requisitos

Você precisa saber:

  • navegar em um projeto no Android Studio;
  • trabalhar com recursos XML e adicioná-los ao Android Studio;
  • modificar e implementar métodos em uma classe existente;
  • criar instâncias de classes do Kotlin, acessar as propriedades delas e chamar métodos;
  • consultar a documentação em developer.android.com para saber mais sobre classes específicas.

O que você aprenderá

Como:

  • usar uma intent explícita para navegar até uma atividade específica;
  • usar uma intent implícita para navegar até o conteúdo de outro app;
  • adicionar opções de menu para acrescentar botões à barra de apps.

O que você criará

  • Você vai modificar um app de dicionário para implementar a navegação entre telas usando intents e adicionando um menu "opções".

O que é necessário

  • Um computador com o Android Studio instalado.

2. Código inicial

Nas próximas etapas, você trabalhará no app Words. Ele é um app de dicionário simples, com uma lista de letras, palavras para cada letra e a capacidade de procurar definições de cada palavra no navegador.

Parece muita coisa, mas não se preocupe: você não vai precisar criar um app inteiro só para aprender sobre intents. Em vez disso, fornecemos uma versão incompleta do projeto ou um projeto inicial.

Embora todas as telas estejam implementadas, ainda não é possível navegar de uma para outra. Sua tarefa é usar intents para que o projeto inteiro funcione, sem precisar criar tudo do zero.

Fazer o download do código inicial para este codelab

Este codelab oferece um código inicial para você estender com os recursos ensinados. O código inicial pode conter um código que você já conheceu em codelabs anteriores. Ele também pode conter um código desconhecido e que você aprenderá em codelabs futuros.

Ao fazer o download do código inicial no GitHub, o nome da pasta é android-basics-kotlin-words-app-starter. Selecione essa pasta ao abrir o projeto no Android Studio.

Se você estiver familiarizado com os comandos do Git, observe que o código inicial está em uma ramificação chamada "starter". Depois de clonar o repositório, veja o código da ramificação origin/starter. Se você nunca usou comandos do Git, siga as etapas abaixo para fazer o download do código no GitHub.

Para encontrar o código deste codelab e abri-lo no Android Studio, faça o seguinte.

Acessar o código

  1. Clique no URL fornecido. Isso abre a página do GitHub referente ao projeto em um navegador.
  2. Na página do GitHub do projeto, clique no botão Code, que vai mostrar uma caixa de diálogo.

5b0a76c50478a73f.png

  1. Na caixa de diálogo, clique no botão Download ZIP para salvar o projeto no seu computador. Aguarde a conclusão do download.
  2. Localize o arquivo no computador, que provavelmente está na pasta Downloads.
  3. Clique duas vezes para descompactar o arquivo ZIP. Isso vai criar uma nova pasta com os arquivos do projeto.

Abrir o projeto no Android Studio

  1. Inicie o Android Studio.
  2. Na janela Welcome to Android Studio, clique em Open an existing Android Studio project.

36cc44fcf0f89a1d.png

Observação: caso o Android Studio já esteja aberto, selecione a opção File > New > Import Project.

21f3eec988dcfbe9.png

  1. Na caixa de diálogo Import Project, vá até a pasta descompactada do projeto, que provavelmente está na pasta Downloads.
  2. Clique duas vezes nessa pasta do projeto.
  3. Aguarde o Android Studio abrir o projeto.
  4. Clique no botão Run 11c34fc5e516fb1c.png para criar e executar o app. Confira se ele é compilado da forma esperada.
  5. Procure os arquivos do projeto na janela de ferramentas Project para ver como o app está configurado.

3. Visão geral do aplicativo Words

Antes de continuar, reserve um tempo para se familiarizar com o projeto. Você já deve ter familiaridade com todos os conceitos, que foram abordados na unidade anterior. Atualmente, o app consiste em duas atividades, cada uma com uma visualização de reciclagem e um adaptador.

f1e0ec543698f945.png

Você trabalhará especificamente com estes arquivos:

  1. LetterAdapter é usado pela RecyclerView na MainActivity. Cada letra é um botão com um onClickListener, que está vazio no momento. É nesse local que você gerenciará o uso dos botões para navegar até a DetailActivity.
  2. WordAdapter é usado pela RecyclerView na DetailActivity para exibir uma lista de palavras. Embora você ainda não possa navegar até esta tela, saiba que cada palavra também tem um botão correspondente com um onClickListener. É aqui que você adicionará um código para ir até o navegador e mostrar uma definição da palavra.
  3. A MainActivity também precisará de algumas mudanças. É nela que você implementará o menu "opções" para mostrar um botão que permite que os usuários alternem entre os layouts de lista e de grade.

ce3474dba2a9c1c8.png

Quando se sentir confortável com o projeto, siga para a próxima seção para aprender sobre intents.

4. Introdução a intents

Agora que você configurou o projeto inicial, vamos conversar sobre as intents e como usá-las no app.

Uma intent é um objeto que representa uma ação a ser realizada. O uso mais comum, mas não o único, de uma intent é iniciar uma atividade. Há dois tipos de intents: implícitas e explícitas. Uma intent explícita é altamente específica. Nela, você sabe a atividade exata que será iniciada, geralmente uma tela no app.

Uma intent implícita é um pouco mais abstrata. Nela, você informa ao sistema o tipo de ação, como abrir um link, escrever um e-mail ou fazer uma chamada, e o sistema é responsável por descobrir como atender à solicitação. Você provavelmente já viu os dois tipos de intent mesmo sem conhecê-los. Geralmente, ao exibir uma atividade no app, você usa uma intent explícita.

No entanto, para ações que não envolvem necessariamente o app atual (por exemplo, você encontrou uma página de documentação do Android interessante e quer compartilhá-la com amigos), uma intent implícita é usada. Talvez você veja um menu como este, que pergunta qual app usar para compartilhar a página.

e9c77033d9224170.png

Você usa intents explícitas para ações ou apresentações de tela no app atual e é responsável por todo o processo. Normalmente, você usa intents implícitas para realizar ações que envolvem outros apps e dependem do sistema para determinar o resultado final. Você usará os dois tipos de intents no app Words.

702236c6e2276f91.png

5. Configurar uma intent explícita

É hora de implementar sua primeira intent. Na primeira tela, quando o usuário tocar em uma letra, ele será levado para uma segunda tela com uma lista de palavras. A DetailActivity já está implementada. Portanto, basta inicializá-la com uma intent. Como seu app sabe exatamente qual atividade precisa ser iniciada, você usará uma intent explícita.

A criação e o uso de intents podem ser feitos seguindo apenas algumas etapas.

  1. Abra o arquivo LetterAdapter.kt e role para baixo até o onBindViewHolder(). Abaixo da linha que define o texto do botão, configure o onClickListener como holder.button.
holder.button.setOnClickListener {

}
  1. Em seguida, acesse uma referência ao context.
val context = holder.view.context
  1. Crie uma Intent, transmitindo o contexto e o nome da classe da atividade de destino.
val intent = Intent(context, DetailActivity::class.java)

O nome da atividade que você quer mostrar é especificado por DetailActivity::class.java. Um objeto DetailActivity é criado internamente.

  1. Chame o método putExtra, transmitindo "letter" como o primeiro argumento e o texto do botão como o segundo argumento.
intent.putExtra("letter", holder.button.text.toString())

O que é um extra? Lembre-se de que uma intent é simplesmente um conjunto de instruções. Ela ainda não tem uma instância da atividade de destino. Em vez disso, um extra é um dado, como um número ou uma string, que recebe um nome para ser recuperado depois. Isso é semelhante a transmitir um argumento quando você chama uma função. Como uma DetailActivity pode ser exibida para qualquer letra, você precisa informar qual letra será exibida.

Além disso, por que você acha que é necessário chamar toString()? O texto do botão já é uma string, certo?

Mais ou menos. Na verdade, o texto é do tipo CharSequence, que é chamado de interface. No momento, você não precisa saber nada sobre as interfaces do Kotlin, além de que elas são uma forma de garantir que um tipo, como uma String, implemente funções e propriedades específicas. Pense em uma CharSequence como uma representação mais genérica de uma classe semelhante a uma string. A propriedade text de um botão pode ser uma string ou um objeto qualquer que também seja uma CharSequence. No entanto, o método putExtra() aceita uma String, e não qualquer CharSequence. Portanto, você precisa chamar toString().

  1. Chame o método startActivity() no objeto de contexto, transmitindo a intent.
context.startActivity(intent)

Agora, execute o app e tente tocar em uma letra. A tela de detalhes será exibida. Mas, independentemente da letra tocada pelo usuário, a tela de detalhes sempre mostrará palavras para a letra "A". Ainda há algumas tarefas a serem realizadas na atividade detalhada para que ela mostre palavras para qualquer letra transmitida como o extra da intent.

6. Configurar a DetailActivity

Você acabou de criar sua primeira intent explícita. Agora, falaremos sobre a tela de detalhes.

No método onCreate da DetailActivity, após a chamada para setContentView, substitua a letra codificada pelo código para receber o letterId transmitido pela intent.

val letterId = intent?.extras?.getString("letter").toString()

Como tem muita coisa acontecendo ao mesmo tempo, vamos dar uma olhada em cada parte:

Primeiro, de onde vem a propriedade intent? Ela não é uma propriedade da DetailActivity, mas uma propriedade de qualquer atividade. Ela mantém uma referência à intent usada para iniciar a atividade.

A propriedade "extras" é do tipo Bundle e, como você pode imaginar, fornece uma maneira de acessar todos os extras transmitidos à intent.

Essas duas propriedades estão marcadas com um ponto de interrogação. Por quê? A razão é que as propriedades intent e extras são anuláveis, o que significa que elas podem ter um valor ou não. Às vezes, você quer que uma variável seja null. A propriedade intent pode não ser uma Intent de fato (se a atividade não tiver sido iniciada por uma intent) e a propriedade "extras" pode não ser um Bundle, mas um valor chamado null. Em Kotlin, null significa a ausência de um valor. O objeto pode existir ou pode ser null. Se o app tentar acessar uma propriedade ou chamar uma função em um objeto null, ele falhará. Para acessar esse valor com segurança, coloque um "?" após o nome dele. Se a intent for null, o app não tentará acessar a propriedade "extras". Se a extras for nula, seu código não tentará chamar getString().

Como saber quais propriedades exigem um ponto de interrogação para garantir a proteção contra valores nulos? Você saberá isso se o nome do tipo for seguido por um ponto de interrogação ou de exclamação.

2009463ce2fd82f2.png

A última observação é que a letra atual é recuperada por getString, que retorna uma String?. Portanto, o método toString() é chamado para garantir que ela seja uma String e não um valor null.

Agora, quando você executar o app e navegar até a tela de detalhes, verá a lista de palavras para cada letra.

c465ef280fe3792a.png

Como limpar o código

O código para executar a intent e recuperar a letra selecionada fixa o nome do extra, "letter", no código. Embora isso funcione neste pequeno exemplo, essa não é a melhor abordagem para apps grandes, em que há muito mais extras de intents para monitorar.

Você pode simplesmente criar uma constante chamada "letter", mas isso pode ficar inviável quando adicionar mais extras de intent ao app. E em qual classe você colocaria essa constante? Lembre-se de que a string é usada tanto na DetailActivity quanto na MainActivity. Você precisa de uma maneira de definir uma constante que possa ser usada em várias classes e mantenha seu código organizado.

Felizmente, existe um recurso útil do Kotlin que pode ser usado para separar suas constantes e torná-las utilizáveis sem uma instância específica da classe chamada de objetos complementares (link em inglês). Um objeto complementar é semelhante a outros objetos, como instâncias de uma classe. No entanto, só existe uma instância de um objeto complementar durante a execução do programa, Por isso, às vezes ele é chamado de padrão Singleton (link em inglês). Há vários casos de uso para Singletons além do escopo deste codelab. Por enquanto, você usará um objeto complementar como uma maneira de organizar constantes e torná-las acessíveis fora da DetailActivity. Comece usando um objeto complementar para refatorar o código do extra "letter".

  1. Na DetailActivity, logo acima do método onCreate, adicione o seguinte:
companion object {

}

Isso é semelhante à definição de uma classe, exceto pelo uso da palavra-chave object. Há também uma palavra-chave companion, que significa que o objeto está associado à classe DetailActivity, e não é necessário dar um nome de tipo separado a ele.

  1. Dentro das chaves, adicione uma propriedade para a constante "letter".
const val LETTER = "letter"
  1. Para usar a nova constante, atualize sua chamada de letra codificada no método onCreate() da seguinte maneira:
val letterId = intent?.extras?.getString(LETTER).toString()

Observe mais uma vez que você se refere a ela com a notação de ponto, como de costume, mas que a constante pertence à DetailActivity.

  1. Alterne para o LetterAdapter e modifique a chamada para putExtra para usar a nova constante.
intent.putExtra(DetailActivity.LETTER, holder.button.text.toString())

Tudo pronto! Ao refatorar o código, você acabou de torná-lo mais legível e fácil de manter. Se essa ou qualquer outra constante que você adicionar precisar mudar, você pode fazer isso em um único lugar.

Para saber mais sobre objetos complementares, consulte a documentação do Kotlin sobre Expressões e declarações de objeto (link em inglês).

7. Configurar uma intent implícita

Na maioria dos casos, você exibirá atividades específicas no seu app. No entanto, em algumas situações, você pode não saber qual atividade ou app quer iniciar. Na nossa tela de detalhes, cada palavra é um botão que mostra a definição da palavra ao usuário.

Em nosso exemplo, você usará a funcionalidade do dicionário fornecida pela Pesquisa Google. No entanto, em vez de adicionar uma nova atividade ao seu app, você iniciará o navegador do dispositivo para exibir a página de pesquisa.

Então, talvez você precise de uma intent para carregar a página no Chrome, o navegador padrão no Android?

Não é bem isso.

É possível que alguns usuários prefiram usar um navegador de terceiros. O smartphone deles pode vir com um navegador pré-instalado pelo fabricante. Talvez eles tenham o app Pesquisa Google instalado ou até mesmo um app de dicionário de terceiros.

Não é possível saber com certeza quais os apps o usuário instalou. E você não pode presumir a forma como eles querem procurar uma palavra. Esse é um exemplo perfeito de quando usar uma intent implícita. O app fornece informações ao sistema sobre qual ação deve ser tomada, e o sistema descobre o que fazer com essa ação, solicitando ao usuário mais informações conforme necessário.

Faça o seguinte para criar a intent implícita:

  1. Para este app, você fará uma Pesquisa Google pela palavra. O primeiro resultado da pesquisa será uma definição de dicionário da palavra. Como o mesmo URL base é usado para todas as pesquisas, é uma boa ideia defini-lo como uma constante. Na DetailActivity, modifique o objeto complementar para adicionar uma nova constante, SEARCH_PREFIX. Esse é o URL base da Pesquisa Google.
companion object {
   const val LETTER = "letter"
   const val SEARCH_PREFIX = "https://www.google.com/search?q="
}
  1. Em seguida, abra o WordAdapter e, no método onBindViewHolder(), chame setOnClickListener() no botão. Comece criando um URI para a consulta da pesquisa. Ao chamar o método parse() para criar um URI usando uma String, você precisa usar a formatação de string para que a palavra seja anexada ao SEARCH_PREFIX.
holder.button.setOnClickListener {
    val queryUrl: Uri = Uri.parse("${DetailActivity.SEARCH_PREFIX}${item}")
}

Se você estiver se perguntando o que é um URI, não se trata de um erro de digitação, mas sim da sigla de Uniform Resource Identifier. Talvez você já saiba que um URL ou Uniform Resource Locator é uma string que aponta para uma página da Web. Um URI é um termo mais geral para esse formato. Todos os URLs são URIs, mas nem todos os URIs são URLs. Outros URIs, por exemplo, um endereço de um número de telefone, começam com tel:, mas são considerados um URN ou Uniform Resource Name, em vez de um URL. O tipo de dados usado para representar ambos é chamado de URI.

828cef3fdcfdaed.png

Observe que não há referência a nenhuma atividade no seu app aqui. Você só fornece um URI, sem informar como ele será usado.

  1. Depois de definir o queryUrl, inicialize um novo objeto intent.
val intent = Intent(Intent.ACTION_VIEW, queryUrl)

Em vez de transmitir um contexto e uma atividade, transmita uma Intent.ACTION_VIEW junto ao URI.

A ACTION_VIEW é uma intent genérica que aceita um URI, no seu caso, um endereço da Web. O sistema, então, saberá que precisa processar essa intent abrindo o URI no navegador da Web do usuário. Alguns outros tipos de intent incluem:

  • CATEGORY_APP_MAPS: para inicializar apps de mapas.
  • CATEGORY_APP_EMAIL: para inicializar apps de e-mail.
  • CATEGORY_APP_GALLERY: para inicializar apps de galeria (fotos).
  • ACTION_SET_ALARM: para configurar um alarme em segundo plano.
  • ACTION_DIAL: para inicializar uma chamada.

Para saber mais, consulte a documentação de algumas intents usadas com frequência.

  1. Por fim, mesmo que não esteja inicializando uma atividade específica no app, você está instruindo o sistema a iniciar outro app chamando startActivity() e transmitindo a intent.
context.startActivity(intent)

Agora, ao iniciar o app, navegue até a lista de palavras e toque em uma delas. O dispositivo acessará o URL ou apresentará uma lista de opções, dependendo dos apps instalados.

O comportamento exato varia para cada usuário, proporcionando uma experiência perfeita para todos, sem complicar o código.

8. Configurar o menu e os ícones

Agora que você já tornou o app totalmente navegável ao adicionar intents explícitas e implícitas, é hora de adicionar uma opção de menu para que os usuários possam alternar entre layouts de lista e grade para as letras.

Você provavelmente já percebeu que muitos apps têm essa barra na parte superior da tela. Ela é chamada de barra de apps. Além de mostrar o nome do app, ela pode ser personalizada para hospedar várias funcionalidades, como atalhos para ações úteis ou menus flutuantes.

dda2fc115721ca96.png

Nesse app, não adicionaremos um menu completo. Mas você aprenderá a adicionar um botão personalizado à barra de aplicativos para que o usuário possa alterar o layout.

  1. Primeiro, você precisa importar dois ícones para representar as visualizações de grade e de lista. Adicione os recursos vetorizados de clip art chamados "view module" (nomeie-o como ic_grid_layout) e "view list" (nomeie-o como ic_linear_layout). Se você precisar se lembrar como adicionar ícones do Material Design, consulte as instruções nesta página.

44c530717478f2e6.png

  1. Você também precisa de uma maneira de informar ao sistema quais opções serão exibidas na barra de apps e quais ícones serão usados. Para fazer isso, adicione um novo arquivo de recursos clicando com o botão direito do mouse na pasta res e selecionando New > Android Resource File. Defina o campo Resource Type como Menu e o campo File Name como layout_menu.

c4f83806a1aa121b.png

  1. Clique em OK.
  2. Abra res/Menu/layout_menu. Substitua o conteúdo de layout_menu.xml pelo seguinte:
<menu xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto">
   <item android:id="@+id/action_switch_layout"
       android:title="@string/action_switch_layout"
       android:icon="@drawable/ic_linear_layout"
       app:showAsAction="always" />
</menu>

A estrutura do arquivo de menu é bem simples. Assim como um layout começa com um gerenciador de layout para conter visualizações individuais, um arquivo XML de menu começa com uma tag de menu, que contém opções individuais.

O menu tem apenas um botão, com algumas propriedades:

  • id: assim como nas visualizações, a opção de menu tem um ID para que possa ser referenciada no código.
  • title: esse texto não estará visível no seu caso, mas pode ser útil para que os leitores de tela identifiquem o menu.
  • icon: o padrão é ic_linear_layout. No entanto, esse botão será ativado e desativado para exibir o ícone de grade quando for selecionado.
  • showAsAction: informa ao sistema como exibir o botão. Como esse método está definido como "always", o botão sempre ficará visível na barra de apps e não se tornará parte de um menu flutuante.

Obviamente, apenas definir as propriedades não significa que o menu realmente funcionará.

Ainda será necessário adicionar um código ao arquivo MainActivity.kt para que o menu funcione.

9. Implementar o botão de menu

Para ver o botão de menu em ação, há algumas coisas que precisam ser feitas no arquivo MainActivity.kt.

  1. Primeiro, é uma boa ideia criar uma propriedade para monitorar em que estado do layout o app está. Isso facilitará a alternância do botão de layout. Defina o valor padrão como true, já que o gerenciador de layout linear será usado por padrão.
private var isLinearLayoutManager = true
  1. Quando o usuário alternar o botão, você quer que a lista de itens se transforme em uma grade de itens. Como você aprendeu nas visualizações de reciclagem, há muitos gerenciadores de layout diferentes. Um deles, o GridLayoutManager permite que vários itens sejam exibidos em uma única linha.
private fun chooseLayout() {
    if (isLinearLayoutManager) {
        recyclerView.layoutManager = LinearLayoutManager(this)
    } else {
        recyclerView.layoutManager = GridLayoutManager(this, 4)
    }
    recyclerView.adapter = LetterAdapter()
}

Aqui, você usará uma instrução if para atribuir o gerenciador de layout. Além de configurar o layoutManager, esse código também atribui o adaptador. O LetterAdapter é usado para layouts de lista e de grade.

  1. Ao configurar inicialmente o menu em XML, você forneceu um ícone estático. No entanto, depois de alternar o layout, você precisará atualizar o ícone para refletir a nova função, retornando ao layout de lista. Basta definir os ícones de layout linear e de grade, com base no layout ao qual o botão voltará na próxima vez que for tocado.
private fun setIcon(menuItem: MenuItem?) {
   if (menuItem == null)
       return

   // Set the drawable for the menu icon based on which LayoutManager is currently in use

   // An if-clause can be used on the right side of an assignment if all paths return a value.
   // The following code is equivalent to
   // if (isLinearLayoutManager)
   //     menu.icon = ContextCompat.getDrawable(this, R.drawable.ic_grid_layout)
   // else menu.icon = ContextCompat.getDrawable(this, R.drawable.ic_linear_layout)
   menuItem.icon =
       if (isLinearLayoutManager)
           ContextCompat.getDrawable(this, R.drawable.ic_grid_layout)
       else ContextCompat.getDrawable(this, R.drawable.ic_linear_layout)
}

O ícone é definido condicionalmente com base na propriedade isLinearLayoutManager.

Para que o app use o menu, é necessário substituir mais dois métodos.

  • onCreateOptionsMenu: em que você infla o menu "opções" e realiza qualquer outra configuração.
  • onOptionsItemSelected: em que você realmente chamará o chooseLayout() quando o botão for selecionado.
  1. Modifique o onCreateOptionsMenu da seguinte maneira:
override fun onCreateOptionsMenu(menu: Menu?): Boolean {
   menuInflater.inflate(R.menu.layout_menu, menu)

   val layoutButton = menu?.findItem(R.id.action_switch_layout)
   // Calls code to set the icon based on the LinearLayoutManager of the RecyclerView
   setIcon(layoutButton)

   return true
}

Nada demais até aqui. Depois de inflar o layout, chame o setIcon() para garantir que o ícone esteja correto, com base no layout. O método retorna um Boolean. Retorne true aqui, já que você quer que o menu "opções" seja criado.

  1. Implemente onOptionsItemSelected conforme mostrado, com apenas mais algumas linhas de código.
override fun onOptionsItemSelected(item: MenuItem): Boolean {
   return when (item.itemId) {
       R.id.action_switch_layout -> {
           // Sets isLinearLayoutManager (a Boolean) to the opposite value
           isLinearLayoutManager = !isLinearLayoutManager
           // Sets layout and icon
           chooseLayout()
           setIcon(item)

           return true
       }
       //  Otherwise, do nothing and use the core event handling

       // when clauses require that all possible paths be accounted for explicitly,
       //  for instance both the true and false cases if the value is a Boolean,
       //  or an else to catch all unhandled cases.
       else -> super.onOptionsItemSelected(item)
   }
}

Esse método será chamado sempre que um item de menu for tocado. Então, você precisa verificar qual item está sendo tocado. Acima, você usa uma instrução when. Se o id corresponder ao item de menu action_switch_layout, você negará o valor do isLinearLayoutManager. Em seguida, chame o chooseLayout() e o setIcon() para atualizar a IU corretamente.

Mais uma coisa antes de executar o app. Como o gerenciador de layout e o adaptador agora estão definidos no chooseLayout(), substitua esse código no onCreate() para chamar o novo método. O onCreate() ficará assim após a mudança.

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)

   val binding = ActivityMainBinding.inflate(layoutInflater)
   setContentView(binding.root)

   recyclerView = binding.recyclerView
   // Sets the LinearLayoutManager of the recyclerview
   chooseLayout()
}

Agora, execute o app e alterne entre as visualizações de lista e de grade usando o botão de menu.

10. Código da solução

O código da solução deste codelab está no projeto abaixo.

Para encontrar o código deste codelab e abri-lo no Android Studio, faça o seguinte.

Acessar o código

  1. Clique no URL fornecido. Isso abre a página do GitHub referente ao projeto em um navegador.
  2. Na página do GitHub do projeto, clique no botão Code, que vai mostrar uma caixa de diálogo.

5b0a76c50478a73f.png

  1. Na caixa de diálogo, clique no botão Download ZIP para salvar o projeto no seu computador. Aguarde a conclusão do download.
  2. Localize o arquivo no computador, que provavelmente está na pasta Downloads.
  3. Clique duas vezes para descompactar o arquivo ZIP. Isso vai criar uma nova pasta com os arquivos do projeto.

Abrir o projeto no Android Studio

  1. Inicie o Android Studio.
  2. Na janela Welcome to Android Studio, clique em Open an existing Android Studio project.

36cc44fcf0f89a1d.png

Observação: caso o Android Studio já esteja aberto, selecione a opção File > New > Import Project.

21f3eec988dcfbe9.png

  1. Na caixa de diálogo Import Project, vá até a pasta descompactada do projeto, que provavelmente está na pasta Downloads.
  2. Clique duas vezes nessa pasta do projeto.
  3. Aguarde o Android Studio abrir o projeto.
  4. Clique no botão Run 11c34fc5e516fb1c.png para criar e executar o app. Confira se ele é compilado da forma esperada.
  5. Procure os arquivos do projeto na janela de ferramentas Project para ver como o app está configurado.

11. Resumo

  • As intents explícitas são usadas para navegar até atividades específicas no app.
  • Intents implícitas correspondem a ações específicas (como abrir um link ou compartilhar uma imagem) e deixam que o sistema determine como cumprir a intent.
  • As opções de menu permitem adicionar botões e menus à barra de apps.
  • Objetos complementares oferecem uma maneira de associar constantes reutilizáveis a um tipo, em vez de uma instância desse tipo.

Para realizar uma intent:

  • Acesse uma referência do contexto.
  • Crie um objeto Intent fornecendo uma atividade ou um tipo de intent (dependendo se ela é explícita ou implícita).
  • Transmita todos os dados necessários chamando putExtra().
  • Chame a startActivity() transmitindo o objeto intent.

12. Saiba mais