topics/ui/declaring-layout.jd

page.title=Layouts
page.tags=vista,grupodevistas
@jd:body

<div id="qv-wrapper">
<div id="qv">
  <h2>Neste documento</h2>
<ol>
  <li><a href="#write">Programao do XML</a></li>
  <li><a href="#load">Carregamento do recurso XML</a></li>
  <li><a href="#attributes">Atributos</a>
    <ol>
      <li><a href="#id">ID</a></li>
      <li><a href="#layout-params">Parmetros do layout</a></li>
    </ol>
  </li>
  <li><a href="#Position">Posio do layout</a></li>
  <li><a href="#SizePaddingMargins">Tamanho, preenchimento e margens</a></li>
  <li><a href="#CommonLayouts">Layouts comuns</a></li>
  <li><a href="#AdapterViews">Criao de layouts com um adaptador</a>
    <ol>
      <li><a href="#FillingTheLayout">Preenchimento da vista de um adaptador com dados</a></li>
      <li><a href="#HandlingUserSelections">Tratamento de eventos de clique</a></li>
    </ol>
  </li>
</ol>

  <h2>Classes principais</h2>
  <ol>
    <li>{@link android.view.View}</li>
    <li>{@link android.view.ViewGroup}</li>
    <li>{@link android.view.ViewGroup.LayoutParams}</li>
  </ol>

  <h2>Veja tambm</h2>
  <ol>
    <li><a href="{@docRoot}training/basics/firstapp/building-ui.html">Construo de uma interface do usurio
simples</a></li> </div>
</div>

<p>O layout define a estrutura visual para uma interface do usurio, como a IU de uma <a href="{@docRoot}guide/components/activities.html">atividade</a> ou de um <a href="{@docRoot}guide/topics/appwidgets/index.html">widget de aplicativo</a>.
 possvel declarar um layout de dois modos:</p>
<ul>
<li><strong>Declarar elementos da IU em XML</strong>. O Android fornece um vocabulrio XML
direto que corresponde s classes e subclasses de View, como as de widgets e layouts.</li>
<li><strong>Instanciar elementos do layout em tempo de execuo</strong>.
O aplicativo pode criar objetos de View e ViewGroup (e manipular suas propriedades) programaticamente. </li>
</ul>

<p>A estrutura do Android  flexvel para usar um destes mtodos ou ambos para declarar e gerenciar a IU do seu aplicativo. Por exemplo: voc pode declarar um layout padro do aplicativo em XML, e incluir os elementos da tela que aparecero neles e suas propriedades. Em seguida, voc poderia adicionar cdigos ao aplicativo que modificariam o estado dos objetos da tela, inclusive os declarados em XML, em tempo de execuo. </p>

<div class="sidebox-wrapper">
<div class="sidebox">
  <ul>
  <li>A <a href="{@docRoot}tools/sdk/eclipse-adt.html">Extenso
ADT para Eclipse</a> oferece uma pr-visualizao do layout do XML &mdash;
com o arquivo XML aberto, selecione a guia <strong>Layout</strong>.</li>
  <li>Pode-se usar tambm a
  ferramenta de <a href="{@docRoot}tools/debugging/debugging-ui.html#hierarchyViewer">Visualizao de hierarquia</a>
para depurar layouts &mdash; ela revela os valores de propriedades do layout,
desenha o esqueleto do layout com indicadores de preenchimento/margens e vistas totalmente renderizadas
e a depurao pode ocorrer no emulador ou no dispositivo.</li>
  <li>A ferramenta <a href="{@docRoot}tools/debugging/debugging-ui.html#layoutopt">layoutopt</a> permite
  a rpida anlise dos layouts e hierarquias com relao a ineficincias e outros problemas.</li>
</div>
</div>

<p>A vantagem de declarar a IU em XML  separar melhor a apresentao do aplicativo a partir do cdigo que controla seu comportamento. As descries da IU so externas ao cdigo do aplicativo, ou seja,  possvel modific-la ou adapt-la sem modificar o cdigo-fonte e recompilar. Por exemplo:  possvel criar layouts XML para diferentes orientaes de tela, diferentes tamanhos de tela de dispositivos e diferentes idiomas. Alm disso, a declarao de layout em XML facilita a exibio da estrutura da sua IU, o que facilita a depurao de problemas. Assim sendo, este documento se concentrar em ensinar a declarar o layout em XML. Se voc
estiver interessado em instanciar objetos View em tempo de execuo, consulte as referncias das classes
{@link android.view.ViewGroup} e {@link android.view.View}.</p>

<p>Em geral, o vocabulrio XML para declarar elementos da IU segue rigorosamente a estrutura e a atribuio de nome s classes e aos mtodos, em que os nomes de elementos correspondem a nomes de classe e nomes de atributos correspondem a mtodos. Na verdade, a correspondncia normalmente  to direta que  possvel supor qual atributo XML corresponde a determinado mtodo de classe ou supor qual classe corresponde a certo elemento XML. Contudo, observe que nem todo vocabulrio  idntico. Em alguns casos, h pequenas diferenas de nome. Por exemplo:
o elemento EditText tem um atributo <code>text</code> que corresponde
a <code>EditText.setText()</code>. </p>

<p class="note"><strong>Dica:</strong> Veja os diferentes tipos de layout em <a href="{@docRoot}guide/topics/ui/layout-objects.html">Objetos
de layout comuns</a>. Tambm h uma coleo de tutoriais sobre a criao de diversos layouts
no guia de tutorial <a href="{@docRoot}resources/tutorials/views/index.html">Vistas de boas-vindas</a>.</p>

<h2 id="write">Programao do XML</h2>

<p>Usando o vocabulrio XML do Android,  possvel projetar rapidamente layouts de IU e os elementos de tela intrnsecos do mesmo modo que se cria pginas web em HTML &mdash; com uma srie de elementos aninhados. </p>

<p>Cada arquivo de layout deve conter exatamente um elemento raiz, que deve ser um objeto View ou ViewGroup. Com o elemento raiz definido,  possvel adicionar objetos ou widgets de layout extras como elementos filho para construir gradualmente uma hierarquia de View que define o layout. Por exemplo: eis um layout XML que usa um {@link android.widget.LinearLayout} vertical
para conter uma {@link android.widget.TextView} e um {@link android.widget.Button}:</p>
<pre>
&lt;?xml version="1.0" encoding="utf-8"?>
&lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical" >
    &lt;TextView android:id="@+id/text"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:text="Hello, I am a TextView" />
    &lt;Button android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello, I am a Button" />
&lt;/LinearLayout>
</pre>

<p>Aps declarar o layout no XML, salve o arquivo com uma extenso <code>.xml</code>
no diretrio <code>res/layout/</code> do projeto do Android para compil-lo adequadamente. </p>

<p>Veja mais informaes sobre a sintaxe de um arquivo XML de layout no documento <a href="{@docRoot}guide/topics/resources/layout-resource.html">Recursos de layout</a>.</p>

<h2 id="load">Carregamento do recurso XML</h2>

<p>Ao compilar o aplicativo, cada arquivo de layout XML  compilado
em um recurso {@link android.view.View}. Deve-se carregar o recurso de layout do cdigo do aplicativo
na implementao de retorno de chamada {@link android.app.Activity#onCreate(android.os.Bundle) Activity.onCreate()}.
Para isso, chame <code>{@link android.app.Activity#setContentView(int) setContentView()}</code>,
passando a referncia para o recurso de layout na forma:
<code>R.layout.<em>layout_file_name</em></code>.
Por exemplo: se o layout XML for salvo como <code>main_layout.xml</code>, ser necessrio carreg-lo
para a Atividade desta forma:</p>
<pre>
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_layout);
}
</pre>

<p>O mtodo de retorno de chamada <code>onCreate()</code> na Atividade  chamado pela estrutura do Android quando
ela  inicializada (veja a discusso sobre ciclos de vida no documento
<a href="{@docRoot}guide/components/activities.html#Lifecycle">Atividades</a>
).</p>


<h2 id="attributes">Atributos</h2>

<p>Cada objeto View e ViewGroup aceita uma variedade prpria de atributos XML.
Alguns atributos so especficos de um objeto View (por exemplo, TextView aceita o atributo
<code>textSize</code>), mas esses atributos tambm so herdados de objetos View que possam estender essa classe.
Alguns so comuns a todos os objetos View porque so herdados da classe View raiz (como
o atributo <code>id</code>). Alm disso, outros atributos so considerados "parmetros do layout", que so
os que descrevem determinadas orientaes de layout do objeto View conforme definido pelo objeto
ViewGroup pai daquele objeto.</p>

<h3 id="id">ID</h3>

<p>Qualquer objeto View pode ter um ID de nmero inteiro associado para identificar exclusivamente o View dentro da rvore.
Ao compilar o aplicativo, esse ID  referenciado como um nmero inteiro, mas o ID normalmente
 atribudo no arquivo XML do layout como uma string, no atributo <code>id</code>.
 um atributo XML comum a todos os objetos View
(definido pela classe {@link android.view.View}) e voc o usar com frequncia.
A sintaxe de um ID, dentro de uma tag XML, :</p>
<pre>android:id="&#64;+id/my_button"</pre>

<p>Um smbolo de arroba (@) no incio da string indica que o analisador XML deve analisar e expandir o restante
da string de ID e identific-la como um recurso de ID. O smbolo de mais (+) significa que  um novo nome de recurso que precisa
ser criado e adicionado aos recursos (no arquivo <code>R.java</code>). H diversos outros recursos de ID
oferecidos pela estrutura do Android. Ao referenciar um ID de recurso do Android, no  necessrio ter o smbolo de mais,
mas deve-se adicionar o conjunto de nomes (namespace) do pacote <code>android</code> da seguinte maneira:</p>
<pre>android:id="&#64;android:id/empty"</pre>
<p>Com o conjunto de nomes (namespace) do pacote <code>android</code> em vigor, podemos referenciar um ID da classe
de recursos <code>android.R</code> em vez de um da classe de recursos locais.</p>

<p>Para criar vistas e referenci-las a partir do aplicativo, um modo padro comum :</p>
<ol>
  <li>Definir uma visualizaovistawidget no arquivo de layout e atribuir um ID exclusivo a ele/ela:
<pre>
&lt;Button android:id="&#64;+id/my_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="&#64;string/my_button_text"/>
</pre>
  </li>
  <li>Em seguida, crie uma instncia do objeto de vista e capture-a do layout
(normalmente no mtodo <code>{@link android.app.Activity#onCreate(Bundle) onCreate()}</code>):
<pre>
Button myButton = (Button) findViewById(R.id.my_button);
</pre>
  </li>
</ol>
<p>Definir IDs para objetos de vista  importante ao criar um {@link android.widget.RelativeLayout}.
Em um layout relativo, vistas irms podem definir o layout relativo para outra vista irm
referenciada pelo ID exclusivo.</p>
<p>Os Ids no precisam ser exclusivo por toda a rvore, mas devem ser
exclusivos dentro da parte da rvore em que se est procurando (que pode, com frequncia, ser toda a rvore, portanto  prefervel
ser totalmente exclusivo sempre que possvel).</p>


<h3 id="layout-params">Parmetros do layout</h3>

<p>Os atributos do layout XML chamados <code>layout_<em>something</em></code> definem
parmetros para a View que for apropriado para a ViewGroup em que reside.</p>

<p>Cada classe ViewGroup implementa uma classe aninhada que estende {@link
android.view.ViewGroup.LayoutParams}. Essa subclasse
contm tipos de propriedade que definem o tamanho e a posio de cada vista filha, conforme
o necessrio para o grupo de vistas. Como se pode ver na figura 1, um grupo de vistas
pais define parmetros de layout para cada vista filha (incluindo o grupo de vistas filhas).</p>

<img src="{@docRoot}images/layoutparams.png" alt="" />
<p class="img-caption"><strong>Figura 1.</strong> Vista de uma hierarquia de vistas com parmetros
de layout associados a cada uma delas.</p>

<p>Observe que cada subclasse LayoutParams tem a prpria sintaxe para definir
valores. Cada elemento filho deve definir LayoutParams apropriados para seu pai,
embora possa tambm definir diferentes LayoutParams para os prprios filhos. </p>

<p>Todos os grupos de vistas contm largura e altura (<code>layout_width</code> e
<code>layout_height</code>) e cada vista  obrigatria para defini-las. Muitos
LayoutParams tambm contm margens e bordas opcionais. <p>

<p> possvel especificar largura e altura com medidas exatas, embora no seja
recomendvel na maioria dos casos. Em geral, usa-se uma destas constantes para
definir a largura e a altura: </p>

<ul>
  <li><var>wrap_content</var> instrui a vista a dimensionar-se de acordo com
as medidas exigidas pelo contedo.</li>
  <li><var>match_parent</var> (de nome <var>fill_parent</var> antes da API de nvel 8)
instrui a vista a tornar-se to grande quanto o grupo de vistas pais permitir.</li>
</ul>

<p>Em geral, a especificao de largura e altura de um layout com unidades absolutas, como
pixels, no  recomendada. Em vez disso, usam-se medidas relativas como
unidades de pixel independentes de densidade (<var>dp</var>), <var>wrap_content</var>ou
<var>match_parent</var>,  uma abordagem melhor porque ajuda a garantir
que o aplicativo exiba o contedo adequadamente dentre diversos tamanhos de tela de dispositivos.
Os tipos de medidas aceitos so definidos no documento
<a href="{@docRoot}guide/topics/resources/available-resources.html#dimension">
Recursos disponveis</a>.</p>


<h2 id="Position">Posio do layout</h2>
   <p>
   A geometria de uma vista de um retngulo. As vistas tm uma localizao,
   expressa como um par de coordenadas <em>esquerda</em> e <em>topo</em>
   e duas dimenses, expressas como largura e altura. A unidade de localizao
   e de dimenses  o pixel.
   </p>

   <p>
    possvel recuperar a localizao de uma vista chamando os mtodos
   {@link android.view.View#getLeft()} e {@link android.view.View#getTop()}. O primeiro retorna a coordenada
   esquerda, ou X, do retngulo que representa a vista. O ltimo retorna a coordenada
   topo, ou Y, do retngulo que representa a vista. Esses mtodos
   retornam a localizao da vista em relao ao pai correspondente. Por exemplo:
   quando <code>getLeft()</code> retorna 20, significa que a vista se localiza 20 pixels
   direita da borda esquerda do seu pai direto.
   </p>

   <p>
   Adicionalmente, diversos mtodos de convenincia so oferecidos para evitar clculos
desnecessrias, chamados {@link android.view.View#getRight()} e {@link android.view.View#getBottom()}.
   Esses mtodos retornam as coordenadas das bordas direita e de baixo
   do retngulo que representa a vista. Por exemplo: chamar {@link android.view.View#getRight()}
    semelhante ao seguinte clculo: <code>getLeft() + getWidth()</code>.
   </p>


<h2 id="SizePaddingMargins">Tamanho, preenchimento e margens</h2>
   <p>
   O tamanho de uma vista  expresso por largura e altura. As vistas, na verdade,
   tm dois pares de valores de largura e altura.
   </p>

   <p>
   O primeiro par  conhecido como <em>largura medida</em>
   e <em>altura medida</em>. Essas dimenses definem o tamanho que a vista ter
   dentro da vista pai.
   Para obter as dimenses medidas, chamam-se {@link android.view.View#getMeasuredWidth()}
   e {@link android.view.View#getMeasuredHeight()}.
   </p>

   <p>
   O segundo par  simplesmente conhecido como <em>largura</em> e <em>altura</em> ou,
   s vezes, <em>largura do desenho</em> e <em>altura do desenho</em>. Essas
   dimenses definem o tamanho real da vista na tela, em tempo de desenho e
   aps o layout. Esses valores podem diferir da largura
   e da altura medidas. Para obter os valores de largura e altura, chamam-se
   {@link android.view.View#getWidth()} e {@link android.view.View#getHeight()}.
   </p>

   <p>
   Para medir as dimenses, a vista leva em conta o preenchimento. O preenchimento
    expresso em pixels para a esquerda, a direita e as partes de cima e de baixo da vista.
   O preenchimento pode ser usado para compensar o contedo da vista por um nmero especfico
   de pixels. Por exemplo: um preenchimento  esquerda de 2 empurrar o contedo da vista
   em 2 pixels para a direita da borda esquerda. Para definir o preenchimento, usa-se
   o mtodo {@link android.view.View#setPadding(int, int, int, int)} e consulta-se com as chamadas
   {@link android.view.View#getPaddingLeft()}, {@link android.view.View#getPaddingTop()},
   {@link android.view.View#getPaddingRight()} e {@link android.view.View#getPaddingBottom()}.
   </p>

   <p>
   Mesmo que cada vista possa definir um preenchimento, ela no fornece nenhuma compatibilidade
   com margens. No entanto, os grupos de vistas oferecem essa compatibilidade. Consulte
   {@link android.view.ViewGroup}
   e {@link android.view.ViewGroup.MarginLayoutParams} para ver mais informaes.
   </p>

   <p>Para obter mais informaes sobre dimenses, consulte
   <a href="{@docRoot}guide/topics/resources/more-resources.html#Dimension">Valores de dimenses</a>.
   </p>


<style type="text/css">
div.layout {
  float:left;
  width:200px;
  margin:0 0 20px 20px;
}
div.layout.first {
  margin-left:0;
  clear:left;
}
</style>


<h2 id="CommonLayouts">Layouts comuns</h2>

<p>Cada subclasse da classe {@link android.view.ViewGroup} fornece um modo exclusivo de exibir
as vistas aninhadas dentro dela. Eis alguns dos tipos de layout mais comuns criados
na plataforma Android.</p>

<p class="note"><strong>Observao:</strong> Embora seja possvel aninhar um ou mais layouts em outro
layout para obter o projeto de IU, deve-se procurar manter a hierarquia do layout a menos profunda
possvel. O layout carrega mais rpido se tiver menos layouts aninhados (uma hierarquia de vistas grande
melhor do que uma hierarquia de vistas profunda).</p>

<!--
<h2 id="framelayout">FrameLayout</h2>
<p>{@link android.widget.FrameLayout FrameLayout} is the simplest type of layout
object. It's basically a blank space on your screen that you can
later fill with a single object &mdash; for example, a picture that you'll swap in and out.
All child elements of the FrameLayout are pinned to the top left corner of the screen; you cannot
specify a different location for a child view. Subsequent child views will simply be drawn over
previous ones,
partially or totally obscuring them (unless the newer object is transparent).
</p>
-->


<div class="layout first">
  <h4><a href="layout/linear.html">Layout linear</a></h4>
  <a href="layout/linear.html"><img src="{@docRoot}images/ui/linearlayout-small.png" alt="" /></a>
  <p>Layout que organiza os filhos em uma nica linha horizontal ou vertical. Ele
  cria uma barra de rolagem se o comprimento da janela exceder o comprimento da tela.</p>
</div>

<div class="layout">
  <h4><a href="layout/relative.html">Layout relativo</a></h4>
  <a href="layout/relative.html"><img src="{@docRoot}images/ui/relativelayout-small.png" alt="" /></a>
  <p>Permite especificar a localizao de objetos filhos relativos entre si (filho A
 esquerda do filho B) ou relativos aos pais (alinhados no topo do pai).</p>
</div>

<div class="layout">
  <h4><a href="{@docRoot}guide/webapps/webview.html">Vista web</a></h4>
  <a href="{@docRoot}guide/webapps/webview.html"><img src="{@docRoot}images/ui/webview-small.png" alt="" /></a>
  <p>Exibe pginas da web.</p>
</div>


<h2 id="AdapterViews" style="clear:left">Criao de layouts com um adaptador</h2>

<p>Quando o contedo do layout  dinmico ou no predeterminado,  possvel usar um layout que
torne {@link android.widget.AdapterView} uma subclasse para preencher o layout com vistas em tempo de execuo.
Uma subclasse da classe {@link android.widget.AdapterView} usa um {@link android.widget.Adapter}
para agrupar dados ao seu layout. O {@link android.widget.Adapter} se comporta como um intermedirio entre a fonte
dos dados e o layout do {@link android.widget.AdapterView} &mdash; o {@link android.widget.Adapter}
recupera os dados (de uma fonte como uma matriz ou uma consulta de banco de dados) e converte cada entrada
em uma vista que pode ser adicionada ao layout do {@link android.widget.AdapterView}.</p>

<p>Alguns layouts comuns retornados por um adaptador:</p>

<div class="layout first">
  <h4><a href="layout/listview.html">Vista em lista</a></h4>
  <a href="layout/listview.html"><img src="{@docRoot}images/ui/listview-small.png" alt="" /></a>
  <p>Exibe uma lista de rolagem de coluna nica.</p>
</div>

<div class="layout">
  <h4><a href="layout/gridview.html">Vista em grade</a></h4>
  <a href="layout/gridview.html"><img src="{@docRoot}images/ui/gridview-small.png" alt="" /></a>
  <p>Exibe uma grade de rolagem de colunas e linhas.</p>
</div>


<h3 id="FillingTheLayout" style="clear:left">Preenchimento da vista de adaptador com dados</h3>

<p> possvel preencher um {@link android.widget.AdapterView} como {@link android.widget.ListView}
ou {@link android.widget.GridView} agrupando-se a instncia do {@link android.widget.AdapterView}
a um {@link android.widget.Adapter}, o que recupera dados de uma fonte externa e cria uma {@link
android.view.View} que representa cada entrada de dados.</p>

<p>O Android oferece diversas subclasses de {@link android.widget.Adapter} que so teis para
recuperar diferentes tipos de dados e criar vistas de um {@link android.widget.AdapterView}.
Os dois adaptadores mais comuns so:</p>

<dl>
  <dt>{@link android.widget.ArrayAdapter}</dt>
    <dd>Use esse adaptador quando a fonte de dados for uma matriz. Por padro, {@link
android.widget.ArrayAdapter} cria uma vista para cada item de matriz chamando {@link
java.lang.Object#toString()} em cada item e posicionando o contedo em uma {@link
android.widget.TextView}.
      <p>Por exemplo: se voc tiver uma matriz de strings que deseja exibir em uma {@link
android.widget.ListView}, inicialize um novo {@link android.widget.ArrayAdapter} com
um construtor para especificar o layout de cada string e a matriz de strings:</p>
<pre>
ArrayAdapter&lt;String> adapter = new ArrayAdapter&lt;String>(this,
        android.R.layout.simple_list_item_1, myStringArray);
</pre>
<p>Os argumentos desse construtor so:</p>
<ul>
  <li>O {@link android.content.Context} do aplicativo</li>
  <li>O layout que contm uma {@link android.widget.TextView} para cada string na matriz</li>
  <li>A matriz de strings</li>
</ul>
<p>Em seguida, simplesmente chame
{@link android.widget.ListView#setAdapter setAdapter()} na {@link android.widget.ListView}:</p>
<pre>
ListView listView = (ListView) findViewById(R.id.listview);
listView.setAdapter(adapter);
</pre>

      <p>Para personalizar a aparncia de cada item,  possvel suspender o mtodo {@link
java.lang.Object#toString()} para os objetos na matriz. Ou, para criar uma vista para cada
item diferente de uma {@link android.widget.TextView} (por exemplo, se voc quiser
uma {@link android.widget.ImageView} para cada item da matriz), estenda a classe {@link
android.widget.ArrayAdapter} e suspenda {@link android.widget.ArrayAdapter#getView
getView()} para retornar o tipo de vista que deseja para cada item.</p>

</dd>

  <dt>{@link android.widget.SimpleCursorAdapter}</dt>
    <dd>Use este adaptador quando os dados vierem de um {@link android.database.Cursor}.
Ao usar {@link android.widget.SimpleCursorAdapter},  necessrio especificar um layout a usar para cada
linha no {@link android.database.Cursor} e que colunas no {@link android.database.Cursor}
devem ser inseridas em determinadas vistas do layout. Por exemplo: se voc deseja criar uma lista
de nome e nmero de telefone de pessoas, pode-se realizar uma consulta que retorna um {@link
android.database.Cursor} que contm uma linha para cada pessoa e colunas para os nomes
e nmeros. Assim, cria-se uma matriz de strings especificando quais colunas do {@link
android.database.Cursor} estaro no layout para cada resultado e uma matriz de nmeros inteiros especificando
as vistas correspondentes em que cada coluna deve ser colocada:</p>
<pre>
String[] fromColumns = {ContactsContract.Data.DISPLAY_NAME,
                        ContactsContract.CommonDataKinds.Phone.NUMBER};
int[] toViews = {R.id.display_name, R.id.phone_number};
</pre>
<p>Ao instanciar o {@link android.widget.SimpleCursorAdapter}, passe o layout a usar
para cada resultado, o {@link android.database.Cursor} contendo os resultados e estas duas matrizes:</p>
<pre>
SimpleCursorAdapter adapter = new SimpleCursorAdapter(this,
        R.layout.person_name_and_number, cursor, fromColumns, toViews, 0);
ListView listView = getListView();
listView.setAdapter(adapter);
</pre>
<p>Em seguida, o {@link android.widget.SimpleCursorAdapter} cria uma vista de cada linha
no{@link android.database.Cursor} usando o layout fornecido por meio da insero de cada item de {@code
fromColumns} na vista {@code toViews} correspondente.</p>.</dd>
</dl>


<p>Se durante o curso de vida do aplicativo, voc mudar os dados subjacentes lidos
pelo adaptador, chame {@link android.widget.ArrayAdapter#notifyDataSetChanged()}. Isso
notificar  vista anexada que os dados foram alterados e que ela deve se atualizar.</p>


<h3 id="HandlingUserSelections">Tratamento de eventos de clique</h3>

<p>Para responder a eventos de clique em cada item em um {@link android.widget.AdapterView},
implementa-se a interface {@link android.widget.AdapterView.OnItemClickListener}. Por exemplo:</p>

<pre>
// Create a message handling object as an anonymous class.
private OnItemClickListener mMessageClickedHandler = new OnItemClickListener() {
    public void onItemClick(AdapterView parent, View v, int position, long id) {
        // Do something in response to the click
    }
};

listView.setOnItemClickListener(mMessageClickedHandler);
</pre>