Interface de Usuários - Criando menus

Menus são uma parte importante da interface de usuário em uma atividade que dão aos usuários uma forma familiar de executar tarefas. O Android oferece um framework simples para você adicionar menus padrão para sua aplicação.

Existem três tipos de menus:

• Menus de opção - Coleção primária de itens de menu para uma atividade, que aparecem quando o usuário toca o botão MENU. Quando sua aplicação está rodando em Android 3.0 ou superior, você pode prover um rápido acesso aos itens de menu inserindo-os diretamente na Action bar, como action items.
• Menus de contexto - Uma lista de itens flutuantes que aparecem quando o usuário toca ou segura uma view que está registrada para mostrar menus de contexto.
• Submenu - Uma lista de itens de menu que aparecem quando o usuário toca um item de menu que contém um menu aninhado.

Criando um recurso Menu

Ao invés de instanciar o Menu em seu código de aplicação, você deverá definir um menu e todos os seus itens em um arquivo XML de recurso de menu (carregue-o como um objeto programável) em seu código de aplicação. Usando um recurso de menu para definir seu menu é uma boa prática porque separa o conteúdo do menu de seu código de aplicação. É mais fácil visualizar a estrutura e conteúdo de um menu em um XML.

Para criar um recurso de menu, crie um arquivo XML dentro da pasta res/menu/ e crie o menu com os seguintes elementos:

<menu>
Define o menu, que é um container de itens de menu. Um elemento <menu> deve ser o nó raiz do arquivo e pode guardar um ou mais elementos do tipo <item> e <group>.

<item>
Cria um item de menu. Esse elemento pode conter um menu aninhado de maneira a criar um submenu.

<group>
Um conteiner opcional para contem elementos do tipo <item>. Permite categorizar os itens de menu para que eles guardem propriedades como estado de atividade e visibilidade.

Abaixo um exemplo de um menu chamado game_menu.xml

<?xml version="1.0" encoding="utf-8"?>
   <menu xmlns:android="http://schemas.android.com/apk/res/android">
      <item android:id="@+id/new_game"
         android:icon="@drawable/ic_new_game"
         android:title="@string/new_game" />
      <item android:id="@+id/help"
         android:icon="@drawable/ic_help"
         android:title="@string/help" />
</menu>

Esse exemplo define um menu com dois itens. Cada item inclui os seguintes parâmetros:

android:id
O ID do recurso que deve ser único, que permite a aplicação reconhê-lo quando o usuário o seleciona.

android:icon
Uma referência a uma imagem (drawable) para ser usado como icone do item.

android:title
Uma referência para uma string a ser usada como título do item.

Inflando o recurso de menu

De seu código de aplicação, você pode inflar um recurso de menu (que é converter um recurso XML em um objeto programável) usando MenuInflater.inflate(). Por exemplo, o código seguinte infla o game_menu.xml durante o método de callback onCreateOptionsMenu() para usá-lo como menu de sua atividade.

@Override
public boolean onCreateOptionsMenu(Menu menu) {
   MenuInflater inflater = getMenuInflater();
      inflater.inflate(R.menu.game_menu, menu);
      return true;
}

O método getMenuInflater() retorna um MenuInflater para a atividade. Com esse objet, você pode chamar o método inflate(), que infla o recurso menu em um objeto menu. Nesse exemplo, o recurso de menu definido por game_menu.xml inflado para o Menu que é passado em onCreateOptionsMenu().

Criando um menu de opções

O menu de opções é onde você deverá incluir ações básicas e itens de navegação básicos (por exemplo, um botão para abrir as configurações da aplicação). Itens no menu de opções são acessíveis de duas maneiras distintas: o botão MENU ou na Action Bar (em dispositivos rodando Android 3.0 ou superior).



Quando rodando em dispositivos anteriores à versão 3.0, o menu de opções aparece no rodapé da tela, como mostrada na figura abaixo. Quando aberta, a primeira parte visível do menu de opções é o menu de ícones. Ele guarda os primeiros seis itens de menu. Se você adicionar mais que seis itens a esse menu, o Android vai substituir o sexto item por um que possa abrir um menu flutuante.

No Android 3.0 e superior, itens do menu de opções são inseridos na Action Bar, que aparece no topo da atividade em lugar da barra de título tradicional. Por padrão todos os itens de um menu de opções são colocados em um menu flutuante, que o usuário pode abrir bastando tocar o ícone. Contudo, você pode inserir alguns itens de menu diretamente na Action Bar como items de ação (action items), para acesso instantâneo, como mostrado na imagem abaixo.



Respondendo a ação do usuário

Quando um usuário seleciona um item do menu de opções (incluindo itens de ação da Action Bar), o sistema chama pelo método de atividade onOptionsItemSelected(). Esse método passa o item de menu (menuItem) que o usuário selecionou. Você pode identificar o item chamando getItemId(), que retorna o ID único para o item de menu (definido em android:id). Você pode selecionar uma ação especifica dependendo do item selecionado. Por exemplo:

@Override
public boolean onOptionsItemSelected(MenuItem item) {
  // Captura o menu selecionado
   switch (item.getItemId()) {
      case R.id.new_game:
         newGame();
         return true;
      case R.id.help:
         showHelp();
         return true;
      default:
         return super.onOptionsItemSelected(item);
   }
}

Nesse exemplo, getItemId() chama o ID do item de menu seleciona e faz um switch para comparar o ID aos recursos assinalados aos itens de menu no recurso XML. Quando um switch case tem sucesso em processar o item de menu, ele retorna true para indicar que a seleção do item foi processada. Caso contrário, a cláusula default passa o item de menu para a super classe, no caso dele conseguir processar o item selecionado.

Adicionalmente, o Android 3.0 adiciona a possibilidade de você definir um comportamento para o onClick no recurso XML, usando o atributo android:onClick. Assim, você não precisará implementar onOptionsItemSelected(). Usando o android:onClick, você pode especificar o método a ser chamado quando o usuário seleciona o item de menu. Sua atividade deve implementar o método especificado no android:onClick para que ele aceite um parâmetro único - que é o item de menu selecionado que é passado pelo sistema para o método.

Dica: Se sua aplicação contém múltiplas atividades e algumas delas provêem o mesmo menu de opções (recurso compartilhado, por exemplo), considere criar uma atividade que implementa nada exceto o onCreateOptionsMenu() e onOptionsItemSelected(). Então extenda essa classe para cada atividade que você deverá compartilhar com o mesmo menu de opções. Dessa maneira, você poderá gerenciar apenas um pacote de códigos para manusear o menu de opções e cada classe descendente que herde seu comportamento de menu. 

Se você quer adicionar um item de menu para ua de suas atividades descendentes, faça o override em onCreateOptionsMenu() nessa atividade. Chame super.onCreateOptionsMenu(menu) para que o os items de menu originais sejam criados e então adicione os novos itens de menu usando menu.add().

Mudando itens de menu em tempo de execução

Uma vez que a atividade é criada, o método onCreateOptionsMenu() é chamado apenas uma vez. O sistema mantém e reusa o menu definido nesse método até que a atividade seja destruída. Se você quer mudar o menu de opções em qualquer momento após sua criação, você deve fazer o override do método onPrepareOptionsMenu(). Esse método passa a você o objeto menu em sua existência atual, com todos os itens populados. Assim, você pode remover, adicionar, desabilitar ou habilitar itens de menu dependendo do estado atual de sua aplicação.

Em versões do Android anteriores à 3.0, o sistema chama onPrepareOptionsMenu() a cada vez que o usuário abre o menu de opções.

Em Android 3.0 e superior, você deve chamar o método invalidateOptionsMenu() quando você quer fazer uma atualização do menu, pois o menu está sempre aberto. O sistema vai chamar o método onPrepareOptionsMenu() para que você possa fazer as atualizações necessárias.

Nota: Você nunca deverá mudar os itens de um menu de opções baseado na view que está em foco. Quando está em modo de touchscreen, as visões não conseguem manter o foco, então você NUNCA deverá usar o foco como a base para modificar itens em seu menu de opções. Se você quer prover itens de menu que são sensíveis ao contexto para serem usadas em uma view, use um menu de contexto, que será o próximo item a ser comentado por aqui, juntamente com os submenus.