lightbulb_outline Help shape the future of the Google Play Console, Android Studio, and Firebase. Start survey

Acesso aos recursos

Depois de fornecer um recurso no aplicativo (discutido em Fornecimento de recursos), é possível aplicá-lo referenciando o ID do recurso. Todos os códigos de recursos são definidos na classe R do projeto que a ferramenta aapt gera automaticamente.

Quando o aplicativo é compilado, aapt gera a classe R, que contém códigos de recursos para todos os recursos no diretório res/. Para cada tipo de recurso, há uma subclasse R (por exemplo, R.drawable para todos os recursos drawable) e, para cada recurso daquele tipo, há um número inteiro estático (por exemplo, R.drawable.icon). Esse número inteiro é o ID do recurso que pode ser usado para recuperá-lo.

Apesar de a classe R ser o local onde os códigos de recursos são especificados, nunca deverá ser necessário verificá-la para descobrir um código de recurso. Ele é sempre composto de:

  • O tipo de recurso: Cada recurso é agrupado em um "tipo", como string, drawable e layout. Para saber mais sobre os diferentes tipos, consulte Tipos de recursos.
  • O nome do recurso, que é o nome do arquivo, excluindo a extensão ou o valor no atributo android:name do XML, se o recurso for um valor simples (como uma string).

Há duas formas de acessar um recurso:

  • No código: Usando um número inteiro estático de uma subclasse de sua classe ,R como:
    R.string.hello

    string é o tipo de recurso e hello é o nome do recurso. Há muitas APIs do Android que podem acessar seus recursos quando você fornece um ID de recurso nesse formato. Consulte Acesso aos recursos no código.

  • No XML: Usando uma sintaxe XML especial que também corresponde ao código de recurso definido em sua classe R, como:
    @string/hello

    string é o tipo de recurso e hello é o nome do recurso. Você pode usar essa sintaxe em um recurso XML em qualquer lugar em que um valor é esperado e que seja fornecido em um recurso. Consulte Acesso aos recursos do XML.

Acesso aos recursos no código

Você pode usar um recurso no código passando o ID do recurso como parâmetro do método. Por exemplo, é possível definir uma ImageView para usar o recurso res/drawable/myimage.png usando setImageResource():

ImageView imageView = (ImageView) findViewById(R.id.myimageview);
imageView.setImageResource(R.drawable.myimage);

Também é possível recuperar recursos individuais usando métodos em Resources, dos quais é possível obter uma instância com getResources().

Sintaxe

Esta é a sintaxe para referenciar um recurso no código:

[<package_name>.]R.<resource_type>.<resource_name>
  • <package_name> é o nome do pacote no qual o recurso está localizado (não é obrigatório ao referenciar recursos de seu pacote).
  • <resource_type> é a subclasse R do tipo de recurso.
  • <resource_name> é o nome do arquivo do recurso sem a extensão ou o valor do atributo android:name no elemento XML (para valores simples).

Consulte Tipos de recursos para obter mais informações sobre cada tipo de recurso e como referenciá-los.

Casos de uso

Há muitos métodos que aceitam um parâmetro de ID de recurso e você pode recuperar recursos usando métodos em Resources. É possível obter uma instância de Resources com Context.getResources().

Abaixo há alguns exemplos do acesso aos recursos no código:

// Load a background for the current screen from a drawable resource
getWindow().setBackgroundDrawableResource(R.drawable.my_background_image) ;

// Set the Activity title by getting a string from the Resources object, because
//  this method requires a CharSequence rather than a resource ID
getWindow().setTitle(getResources().getText(R.string.main_title));

// Load a custom layout for the current screen
setContentView(R.layout.main_screen);

// Set a slide in animation by getting an Animation from the Resources object
mFlipper.setInAnimation(AnimationUtils.loadAnimation(this,
        R.anim.hyperspace_in));

// Set the text on a TextView object using a resource ID
TextView msgTextView = (TextView) findViewById(R.id.msg);
msgTextView.setText(R.string.hello_message);

Atenção: Nunca modifique o arquivo R.java manualmente — ele é gerado pela ferramenta aapt quando o projeto é compilado. As alterações serão sobrepostas na próxima compilação.

Acesso aos recursos do XML

Você pode definir valores para alguns atributos e elementos XML usando uma referência a um recurso existente. Isso será feito com frequência ao criar arquivos de layout para fornecer strings e imagens para os widgets.

Por exemplo, se você adicionar um Button ao layout, deverá usar um recurso de string para o texto do botão:

<Button
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/submit" />

Sintaxe

Esta é a sintaxe para referenciar um recurso em um recurso XML:

@[<package_name>:]<resource_type>/<resource_name>
  • <package_name> é o nome do pacote no qual o recurso está localizado (não é obrigatório ao referenciar recursos do mesmo pacote).
  • <resource_type> é a subclasse R do tipo de recurso.
  • <resource_name> é o nome do arquivo do recurso sem a extensão ou o valor do atributo android:name no elemento XML (para valores simples).

Consulte Tipos de recursos para obter mais informações sobre cada tipo de recurso e como referenciá-los.

Casos de uso

Em alguns casos, é preciso usar um recurso para um valor em XML (por exemplo, para aplicar uma imagem desenhável a um widget), mas você também pode usar um recurso em XML em qualquer lugar que aceite um valor simples. Por exemplo, se você tiver o seguinte arquivo de recursos que inclui um recurso de cor e um recurso de string:

<?xml version="1.0" encoding="utf-8"?>
<resources>
   <color name="opaque_red">#f00</color>
   <string name="hello">Hello!</string>
</resources>

É possível usar esses recursos no arquivo de layout a seguir para definir a cor to texto e a string do texto:

<?xml version="1.0" encoding="utf-8"?>
<EditText xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:textColor="@color/opaque_red"
    android:text="@string/hello" />

Nesse caso, não é preciso especificar o nome do pacote na referência do recurso porque os recursos são de seu pacote. Para referenciar um recurso do sistema, é preciso incluir o nome do pacote. Por exemplo:

<?xml version="1.0" encoding="utf-8"?>
<EditText xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:textColor="@android:color/secondary_text_dark"
    android:text="@string/hello" />

Observação: Você deve usar recursos de string o tempo inteiro para que seu aplicativo possa ser localizado para outros idiomas. Para obter informações sobre a criação de recursos alternativos (como strings localizadas), consulte Fornecimento de recursos alternativos. Para obter um guia completo para localizar o aplicativo para outros idiomas, consulte Localização.

Você pode até mesmo usar recursos em XML para criar alias. Por exemplo, é possível criar um recurso desenhável que seja um alias para outro recurso desenhável:

<?xml version="1.0" encoding="utf-8"?>
<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
    android:src="@drawable/other_drawable" />

Isso parece redundante, mas pode ser muito útil ao usar um recurso alternativo. Leia mais sobre Criação de recursos de alias.

Referência a atributos de estilo

Um recurso de atributo de estilo permite referenciar o valor de um atributo no tema atualmente aplicado. Referenciar um atributo de estilo permite personalizar a aparência de elementos da IU deixando-os com estilo que corresponda a variações padrão fornecidas pelo tema atual, em vez de fornecer um valor codificado. Referenciar um atributo de estilo essencialmente significa "usar o estilo que é definido por esse atributo no tema atual".

Para referenciar um atributo de estilo, a sintaxe do nome é quase idêntica ao formato normal de recurso, mas, em vez do símbolo arroba (@), use um ponto de interrogação (?). Além disso, a parte do tipo de recurso é opcional. Por exemplo:

?[<package_name>:][<resource_type>/]<resource_name>

Por exemplo, eis como você pode referenciar um atributo para definir a cor do texto para que corresponda à cor "principal" do texto do tema do sistema:

<EditText id="text"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:textColor="?android:textColorSecondary"
    android:text="@string/hello_world" />

Aqui, o atributo android:textColor especifica o nome de um atributo de estilo no tema atual. O Android agora usa o valor aplicado ao atributo de estilo android:textColorSecondary como o valor para android:textColor nesse widget. Como a ferramenta de recursos do sistema sabe que um recurso de atributo é esperado nesse contexto, não é preciso declarar explicitamente o tipo (que seria ?android:attr/textColorSecondary) — você pode excluir o tipo de attr.

Acesso aos recursos da plataforma

O Android contém uma série de recursos padrão, como estilos, temas e layouts. Para acessá-los, qualifique a referência de recurso com o nome do pacote android. Por exemplo, o Android fornece um recurso de layout que pode ser usado para listar itens em um ListAdapter:

setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, myarray));

Nesse exemplo, simple_list_item_1 é um recurso de layout definido pela plataforma para itens em uma ListView. Você pode usá-lo em vez de criar o próprio layout para itens de lista. Para obter mais informações, consulte o guia do desenvolvedor de Exibição de lista.