O que você deseja fazer agora?

Transcrição

1 powered by Caelum MEUS CURSOS COMUNIDADE Wagner 9130 Pontos Meus cursos // DROID Android e OlaMundo AULA ATIVIDADES Apagar as luzes O que você deseja fazer agora? Começar os exercícios Ver texto Ir para o próximo capítulo Explicação 1/29

2 Atualmente, o poder de processamento dos celulares e outros aparelhos móveis salta à vista. Com esse avanço, também há sensíveis melhorias nas telas e na usabilidade desses dispositivos. Imagine o quão elegante seria, nesse cenário, poder mostrar seu portfólio de aplicações já diretamente na sua mão, sem necessidade de sequer um laptop? Por essas e outras razões, plataformas móveis como ios e Android, estão cada vez mais em evidência e o mercado para tais dispositivos está em plena ascensão. A explosão do Android é a mais recente dentre essas plataformas. O Android é um sistema operacional que roda sobre o núcleo Linux. Desenvolvido pela Open Handset Alliance, a plataforma permite que os desenvolvedores escrevam software na linguagem Java controlando o dispositivo via bibliotecas desenvolvidas pela Google, com o objetivo de ser uma plataforma flexível, aberta e de fácil migração para os fabricantes. O link para documentação, downloads e outros é o Para iniciar com o desenvolvimento do Android, primeiramente baixaremos o Bundle Android para o nosso sistema operacional através da seguinte URI: O Bundle vem com: Software Development Kit do Android (SDK): um conjunto de ferramentas para serem usadas no terminal Eclipse: IDE Android Developer Tools (ADT): um plugin que permite usar o SDK a partir do Eclipse No download estará presente a última versão do SDK do Android. Caso você deseje utilizar outras versões (anteriores ou posteriores), basta acessar o menu Window, Android SDK Manager. Começaremos com um primeiro projeto que mostra uma mensagem de boas vindas ao usuário. Criamos um projeto em branco, e preenchemos o nome da aplicação e pacotes de instalação. No Eclipse, vá em New... e escolha Android Application Project: 2/29

3 Preencha o nome da aplicação como sendo OlaMundo e o package como br.com.caelum.olamundo como na seguinte figura: 3/29

4 Aperte Next. Na tela de Configuração do Projeto, diremos que não desejamos utilizar um ícone customizado, mas sim o padrão do Android. Desmarque a opção Create custom launcher icon. Aperte Next. Criaremos agora nossa primeira tela de atividade do usuário com o sistema. A tela apresentada agora é a de criação da Activity, selecione a opção Blank Activity para começar a tela do zero, como na seguinte figura: Vá para a próxima tela. Configuraremos agora o nome de nossa Activity e o seu respectivo layout. Altere o Layout Name para principal. Como na seguinte figura: 4/29

5 Note que após alterar o nome do layout deixaremos o nome da atividade como OlaMundoActivity e não como PrincipalActivity. Faremos isso para deixar claro que o nome do arquivo xml (um arquivo de configuração do layout) não precisa seguir o mesmo padrão que o da classe. Agora clique em Finish. Muitos arquivos são gerados automaticamente quando criamos um projeto do Android. Para começarmos a entender o que acontece na nossa aplicação, vamos explorar um pouco a estrutura desse projeto. Comece abrindo o arquivo OlaMundoActivity.java em src, no pacote br.com.caelum.helloworld. Você verá algo como: public class OlaMundoActivity extends Activity{ public void oncreate(bundle savedinstancestate){ super.oncreate(savedinstancestate); setcontentview(r.layout.principal); } Note que essa classe herda de Activity. Isso quer dizer que ela representa uma tela da nossa aplicação e implementa a forma como ela reagirá à interação com o usuário e seu conteúdo. 5/29

6 Emulando um dispositivo Para executarmos nossa aplicação criaremos um dispositivo virtual - emularemos um dispositivo - que roda Android. Para isso basta escolhermos as especificações do device que desejamos. O emulador é bastante útil porque nem sempre possuímos vários dispositivos com diferentes tamanhos de tela e versões do Android disponíveis para teste. Para criar um novo simulador, clicamos no menu Windowe depois em Android Virtual Device Manager. Na janela que foi aberta, clique sobre o botão New. Agora preencha as informações conforme a figura abaixo. Com o dispositivo criado, vamos em Run -> Run Configurations... e crie uma nova configuração para Android, nomeando-a e escolhendo a aplicação OlaMundo. 6/29

7 O plugin fará o upload da aplicação para o simulador e o instalará, rodando sua aplicação logo em seguida. O simulador demora um tanto para inicializar, já que está realmente dando boot num Android para o teste. Mas, quando finalmente terminar, o resultado é nossa aplicação: 7/29

8 Apesar da linguagem de alto nível que utilizamos para programar ser o Java, todo código do Android roda sobre uma máquina virtual chamada Dalvik, que utiliza um bytecode diferente. O que acontece é que a SDK do Android já vem munida de um tradutor do formato bytecode Java para o formato dex da virtual machine Dalvik, já fazendo uma série de otimizações focadas em reduzir o espaço do executável gerado. Ciclo de vida de uma Activity Entendamos, agora, os componentes e seus ciclos de vida para que possamos montar um sistema robusto, expansível e com uma performance aceitável para o usuário. O método oncreateé chamado quando uma Activityé executada e ele faz a chamada no sistema. As classes que estendem Activity, de uma forma mais abrangente, interagem tanto com usuários como com serviços ou intenções. Toda Activitytem o ciclo de vida representado na figura a seguir. 8/29

9 Por exemplo, quando nossa aplicação é criada, ocorre o evento oncreate e a classe Activity permite que sobrescrevamos um método de mesmo nome para executar alguma tarefa nesse momento. Na prática usamos esse instante para criar a nossa tela (a View). Existem outros métodos de callback para as transições onstart, onresume, onpause, onstop eondestroy Nosso layout Os layouts são armazenados na pasta res/layout. Você pode conferir a existência do arquivo principal.xml em seu projeto: <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=" 9/29

10 android:orientation="vertical" android:layout_height="fill_parent" > <TextView android:layout_height="wrap_content" </LinearLayout> Nesse exemplo, estamos declarando um layout linear e avisando que, mesmo que não houver conteúdo o bastante para preencher a tela, a aplicação se esticará para ocupar toda a tela. Isso se deve aos parâmetros com fill_parent. Já na tag TextView, note que a altura é determinada como o apenas necessário para mostrar seu conteúdo, configurada como wrap_content. res/values/ Repare na linha em destaque no layout Ela define o texto que aparecerá na tela quando a aplicação rodar. Perceba que ela é apenas uma chave para algum texto. Esse texto está definido em res/values, dentro do arquivo string.xml. <?xml version="1.0" encoding="utf-8"?> <resources> <string name="hello">hello World!</string> <string name="app_name">curso</string> </resources> Essa é uma ideia simples que facilita na internacionalização da sua aplicação. Para traduzi-la para outras línguas, basta criar outros arquivos de valuecom as traduções. Além disso, isolar as Strings do sistema, também potencializa a clareza de alguns pontos do código como por exemplos, chamadas ao banco de dados do Android. res/raw/ Esse é o local para armazenar arquivos de mídia que futuramente serão utilizados no sistema, como mp3, vídeos e outros. res/xml/ Nessa pasta armazenaremos arquivos XML. Se ela não existir, é só criá-la na pasta /res res/drawable Local para armazenar imagens, sejam.gif,.jpgou *.png. Vale relembrar que as imagens da sua aplicação são guardadas em três resoluções, cada uma com sua pasta no sistema: 10/29

11 res/drawable-ldpi/: low, dispositivos de baixa resolução (quase inexistentes); res/drawable-mdpi/: medium, dispositivos de média resolução (raros); res/drawable-hdpi/: high, dispositivos com alta resolução (maioria). Existe também uma classe central e automaticamente gerada que é responsável pelo mapeamento dos elementos da view com o model e o controller. Veja que tudo o que é criado ou declarado na pasta resganha uma representação em Java, que utilizaremos bastante para pegar valores e referenciar itens. Note, no entanto, que essa classe não deve ser alterada a mão. Ela é apenas um recurso que o Android disponibiliza para facilitar a referência a objetos visuais, imagens, strings, etc. publicfinal classr{ public static final class attr{ } public static final class drawable { public static final int caelum=0x7f020000; public static final int icon=0x7f020001; } publicstatic finalclass id { public static final int FrameLayout01=0x7f060000; public static final int botao=0x7f060002; public static final int dest=0x7f060003; public static final int linearl=0x7f060001; public static final int send=0x7f060005; public static final int texto=0x7f060004; } public static final class layout{ public static final int helloworld=0x7f030000; public static final int layout1=0x7f030001; public static final int main=0x7f030002; public static final int player=0x7f030003; public static final int smsexample=0x7f030004; public static final int widgets=0x7f030005; } public static final class raw{ public static final int musica=0x7f040000; public static final int video=0x7f040001; } public static final class string{ public static final int app_name=0x7f050001; public static final int hello=0x7f050000; } } Note que, dessa forma, das nossas classes java, para acessar qualquer recurso declarado na pasta 11/29

12 res/, fazemos uma referência aos atributos públicos dessa estranha classe R. Por exemplo: Acesso a imagens: R.drawable.icon R.drawable.caelum Acesso a itens da tela declarados nos XMLs de layout: R.id.botao R.id.texto Acesso a arquivos: R.raw.musica R.raw.video Acesso a strings: R.string.app_name R.string.hello Veremos com frequência códigos que pegam esses componentes, strings, imagens através do método findviewbyid, para depois utilizá-los, definir listeners, etc: Button botaodeok =(Button) findviewbyid(r.id.botao); Essa classe Ré gerada pelo plugin do Eclipse e não deve ter seus valores alterados por nós. Ela será utilizada como referência para acessar os diversos componentes da nossa interface. É como uma grande coleção de identificadores, que a plataforma saberá utilizar para localizar seus valores e propriedades de maneira otimizada. O R.javaé gerado de acordo com os diversos arquivos utilizados para configuração da sua aplicação. Se houver algum erro nesses diversos arquivos, é capaz de que o plugin não consiga regerá-lo, dessa forma propagando um erro em quase todos os seus arquivos fonte, dada a ausência da classe R. Devemos então ficar atento e buscar o erro que está impedido sua geração, e tomar cuidado para não importar a classe android.r, que não é a da sua aplicação, e sim uma de uso interno ao Android. Como você já sabe, todas as telas do Android são feitas num arquivo XML, que ficam dentro de res/layout. Lá configuramos os detalhes de cada componente, que são itens gráficos. Dentro do XML, cada componente declarado poderá ser manipulado em código Java. Todos esses componentes são filhos de android.view.view. Esses Views serão futuramente agrupados dentro de ViewGroup. Não coincidentemente, ViewGroupé filha de View, formando o composite pattern que aparece também no Swing, onde Containeré filha de Component. Uma ViewGrouppode conter Viewse inclusive ViewGroupsconforme imagem a seguir: 12/29

13 Algumas pessoas vão chamar esses components de widget, porém há um outro conceito no android, que é uma pequena aplicação que pode rodar dentro da home do dispositivo móvel, também chamado de widget. Durante o curso vamos apresentar alguns dos componentes mais usados em aplicações Android. No momento vamos apresentar algumas importantes propriedades que podem ser configuradas nesses componentes. Precisamos também aprender a vincular comportamento aos componentes da tela, para que possamos interagir com o usuário da aplicação. No momento vamos focar nos componentes mais básicos: Serve para escrevermos um texto na tela do Android, como um label. <TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="caelum explica..." Cada componente possui diversas propriedades. Aliás, layout_widthe layout_heightsão obrigatórios para todos eles. Você poderia utilizar uma medida específica, como em pixels, mas não é recomendado. As opções relativas são mais frequentes, como o wrap_content e match_parent(a partir da versão 2.2, match_parent) aqui utilizados, e veremos mais adiante o significado das principais opções. Serve como campo de edição para o usuário do sistema. <EditText 13/29

14 android:layout_width="match_parent" android:layout_height="wrap_content" Para ler o valor do campo, deve-se invocar gettexte depois tostring: EditText cidade = (EditText) findviewbyid(r.id.cidade); Log.i("Meu Texto: ", cidade.gettext().tostring()) ; Log.ié a forma de utilizarmos o DDMS, o sistema de gerenciamento da máquina Dalvik. Esse log será guardado em uma localização específica do seu dispositivo, e pode ser facilmente visto através do emulador. Este widget é um botão como na web ou em sistemas desktop. <Button android:id="@+id/botaoconfirmar" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="botão" Para usarmos na lógica, devemos buscar o botão e adicionar o listener desejado. Esse listener será disparado quando houver um clique no botão. Para fazer isso, precisamos de uma classe que implemente a interface interna View.OnClickListener: class BotaoDeConfirmarListener implements View.OnClickListener{ public void onclick(view view){ //pegaosdados da Activitye //grava os dados nabasesql } } Dentro de nossa activity, podemos registrar uma instância desse listener para o botão: Button cadastrar =(Button) findviewbyid(r.id.botaoconfirmar); 14/29

15 cadastrar.setonclicklistener(new BotaoDeConfirmarListener())); Mas como a instância de BotaoDeConfirmarListenerpode pegar os dados dos campos que estão na activity? Uma hipótese seria ter diversos getters, e passar thiscomo argumento para o construtor. Ou então já definir o construtor e passar apenas os itens necessários para que o listener funcione. Apesar das duas possibilidades, a forma mais comum é utilizar classes anônimas: Button cadastrar =(Button) findviewbyid(r.id.botaoconfirmar); cadastrar.setonclicklistener(new View.OnClickListener(){ public void onclick(view view){ //pegaosdados da Activity //(agora que temos acesso a todos componentes, fica mais simples) //grava os dados nabasesql } }); O código fica mais curto, mas pode atrapalhar a legibilidade e tornar a classe muito grande e com responsabilidades demais. Caso conheça pouco de classes anônimas, recomendamos o post no blog da Caelum a respeito delas: Se quiser um alerta que precise de uma confirmação do usuário, utilize um AlertDialog. AlertDialog.Builder builder = new AlertDialog.Builder(Aplicacao.this); builder.setmessage(mensagem); builder.setneutralbutton("ok", null); AlertDialog dialog = builder.create(); dialog.settitle(titulo); dialog.show(); Utilizado frequentemente para confirmar operações. O alerta pode ser muito customizado, e em vez de apresentar um texto, pode até mesmo apresentar uma view customizada dentro de seu espaço. 15/29

16 Componentes possuem atributos específicos a seu comportamento, mas muitos deles possuem atributos que são comuns e que aparecem com frequência. Já vimos alguns deles, outros são: android:id: Especifica a identificação no programa android:layout_width: Especifica a largura android:layout_height: Especifica a altura android:text: Essa propriedade serve para mostrar o texto que é passado como parâmetro. android:textcolor: Essa propriedade serve para definir uma cor para o texto exibido. android:background: Essa propriedade serve para definir uma cor de fundo. android:textstyle: Essa propriedade serve para definir um estilo a fonte (negrito e/ou itálico). android:textsize: Essa propriedade serve para definir o tamanho da fonte. O tamanho da fonte pode ser especificado em várias notações : px (pixels),sp(scaled-pixels), mm(milímetros), in (inches) e etc. android:typeface: Essa propriedade serve para definir uma fonte ao texto (Arial, Times NewRoman, Courier New e etc). android:capitalize: Essa propriedade serve para definir o tipo capitalização das palavras. Por padrão, o valor e "none"(nenhum). android:password: Com essa propriedade você habilita a digitação de senhas. android:visibility: Define se o componente deve ser visível desde a primeira aparição dessa tela. android:inputtype: Define o teclado para a inserção de dados. Entrou no lugar de algumas propriedades que foram depreciadas Nome dos componentes Cada objeto utilizado nos xmls tem a Quando é o id de um componente visual (View), 16/29

17 Quando você identifica o idde um widget, ele é compilado e aparece na classe R.java. Por exemplo, se o id na identificação da sua lógica, apareceria R.telaDeCadastro.botaoConfirmacao. Outra abordagem à criação de listeners é configurar no xml da viewum método para ser invocado na Activityrelacionada a ela. Fazemos isso colocando o nome do método a ser executado no atributo onclickda tag Button: <LinearLayout...> <EditText...> <Button android:text="copiar texto" android:id="@+id/botao" android:layout_width="match_parent" android:layout_height="wrap_content" android:onclick="imprime" </Button> <TextView...> </LinearLayout> Agora basta implementarmos na Acivityum método chamado imprime que recebe uma View public class OlaMundoActivity extends Activity{ //... outros métodos } public void imprime(view view){ } Log.i("Informação:","Botaoclicado!"); Quando definimos um arquivo de layout, jogamos dentro dele todos os componentes que gostaríamos de ter na tela. Uma questão que fica é: como esses componentes estarão dispostos? Apesar deles possuírem diretivas em relação a sua altura e largura, quem vem primeiro? Quem estará próximo do outro? Como definir com mais exatidão esse posicionamento? Assim como o Swing possui seus LayoutManagers, o Android possui classes filhas de ViewGroup, sendo que alguns deles agem como os layout managers. Eles definirão como seu layout será aplicado aos diversos componentes (Views) contidos nele. É comum misturar diferentes layouts em uma mesma tela para obter um resultado mais agradável visualmente. Por default, e um dos mais usados, temos o LinearLayout, que utilizamos até esse momento. 17/29

18 Este layout é utilizado para alinhar horizontalmente ou verticalmente o conteúdo da tela do Android. <LinearLayout xmlns:android=" android:orientation="horizontal" android:layout_height="fill_parent"> : </LinearLayout> No modo horizontal podemos ter um resultado estranho: <LinearLayout xmlns:android=" android:orientation="vertical" android:layout_height="fill_parent"> : </LinearLayout> 18/29

19 Utilizado para dividir a tela em células. <TableLayout xmlns:android=" android:layout_height="fill_parent"> <TableRow> : </TableRow> <TableRow> : </TableRow> <TableRow> : </TableRow> </TableLayout> Utilizado para definir exatamente as posições na tela. Esse layout foi depreciado, a Google recomenda que não usemos em produção. <?xml version="1.0" encoding="utf-8"?> <AbsoluteLayout xmlns:android=" android:layout_height="fill_parent" > <TextView 19/29

20 android:text="texto Centralizado" android:textcolor="#ffff00" android:layout_height="wrap_content" android:layout_x="100px" android:layout_y="20px" <TextView android:text="texto Esquerdo" android:textcolor="#ff0000" android:layout_height="wrap_content" android:layout_y="40px" android:layout_x="15px" </AbsoluteLayout> O RelativeLayout tem sido cada vez mais usado para a organização das telas do dispositivo por permitir que os componentes sejam alocados na tela com relação à outros componentes ou à própria tela. Com este layout podemos usar algumas tags para fazer este alinhamento. Segue uma pequena lista: android:layout_aligntop="@+id/item" - Alinha o topo do componente em relação a outro android:layout_alignleft="@+id/item" - Alinha a esquerda do componente em relação a outro android:layout_toleftof="@+id/item" - Alinhado à esquerda do componente android:layout_torightof="@+id/item" - Alinhado à direita do componente android:layout_below="@+id/item" - Alinha abaixo de outro componente android:layout_centerhorizontal="true" - Alinhado no centro horizontal android:layout_centervertical="true" - Alinhado no centro vertical android:layout_alignparenttop="true" - Alinhado em cima da tela android:layout_alignparentbottom="true" - Alinhado em baixo da tela android:layout_alignparentleft="true" - Alinhado à esquerda android:layout_alignparentright="true" - Alinhado à direita Mas lembre-se que o Graphical Layoutvai te ajudar a fazer esta organização. A dica de ouro, é colocar id's adequados aos seus componentes. É comum misturarmos diferentes layouts para fazer telas um pouco mais complexas, um único layout nem sempre é o suficiente. Além do que vimos, ainda temos: 20/29

21 FrameLayout - Praticamente sem layout. As Views ficam umas em cima das outras. As vezes é o que precisamos para a nossa tela, como quando vamos montar um video com legendas. TableLayout - Ele monta uma tabela na tela com diversas linhas (TableRow). Nestas linhas, as colunas são a quantidade de views nelas colocadas GridView - Serve para você mostrar diversas views numa mesma tela TabLayout - Como o nome diz, possibilita a colocação de abas na nossa aplicação Um importante recurso de Layout no Android é o atributo layout_gravity. Através dele podemos influenciar no posicionamento de nossas Views. Se criarmos um texto dentro de um FrameLayoutele ficará no topo da tela, na esquerda por padrão. <FrameLayout xmlns:android=" android:layout_height="fill_parent"> 21/29

22 <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="testando Layouts" android:textsize="30sp" </FrameLayout> Vamos agora customizar o posicionamento do TextView. Se quisermos que ele seja um título e apareça centralizado no topo da tela podemos utilizar o layout_gravity com o valor center_horizontal. Conforme código abaixo: <FrameLayout xmlns:android=" android:layout_height="fill_parent"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="testando Layouts" android:textsize="30sp" 22/29

23 android:layout_gravity="center_horizontal" </FrameLayout> O resultado está representado na imagem abaixo: Podemos também determinar que nosso TextViewdeve aparecer no centro vertical, usando o valor center_vertical para nosso layout_gravity. <FrameLayout xmlns:android=" android:layout_height="fill_parent"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="testando Layouts" android:textsize="30sp" android:layout_gravity="center_vertical" </FrameLayout> 23/29

24 O resultado: Repare que o TextViewencontra-se no centro vertical, mas voltou a estar alinhado à esquerda. Se quisermos que ele esteja centralizado tanto vertical quanto horizontalmente podemos utilizar mais de um valor para o layout_gravityusando o caractere ("pipe") para concatenar os valores. Isso não é necessário para o caso do centro da tela já que existe o valor center. No exemplo abaixo demonstramos como colocar um TextViewcentralizado na tela e outro no canto inferior direito utilizando o layout_gravity. <FrameLayout xmlns:android=" android:layout_height="fill_parent"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="testando Layouts" android:textsize="30sp" android:layout_gravity="center" <TextView 24/29

25 android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="direita inferior" android:textsize="30sp" android:layout_gravity="bottom right" </FrameLayout> Quando criamos um elemento de nossa Viewpodemos também estar preocupados em como posicionar seu interior. Suponha agora que desejamos colocar um texto na cor preta em um fundo branco. Esse elemento da nossa tela deverá estar dentro de um FrameLayoutque por sua vez terá um fundo preto. Podemos customizar um TextViewpara que ele tenha essa aparência: <FrameLayout xmlns:android=" android:layout_height="fill_parent"> <TextView android:layout_width="250dp" android:layout_height="250dp" android:text="com fundo" 25/29

26 android:textsize="30sp" android:textcolor="#000000" android:background="#ffffff" android:layout_gravity="center" </FrameLayout> O código anterior vai gerar uma tela conforme a imagem a seguir: Nosso TextViewde fundo branco está centralizado na tela, porém no interior do TextViewo texto encontra-se posicionado na parte superior esquerda. Para centralizarmos o texto no interior do TextViewpodemos usar o atributo gravityjuntamente com o layout_gravitypreviamente utilizado. <FrameLayout xmlns:android=" android:layout_height="fill_parent"> <TextView android:layout_width="250dp" android:layout_height="250dp" android:text="com fundo" 26/29

27 android:textsize="30sp" android:textcolor="#000000" android:background="#ffffff" android:layout_gravity="center" android:gravity="center" </FrameLayout> Quando o assunto é layout, outro artifício do desenvolvedor Android é o uso do layout_weight. Quando existe um espaço sobrando na tela, através da propriedade layout_weightpodemos orientar o Android a dividir esse espaço aplicando um peso maior ou menor para os elementos da View. Para ilustrar no código abaixo vamos colocar três Button'socupando toda a largura da tela, porém a altura queremos dividir de tal maneira que o segundo botão tenha o dobro da altura do primeiro e o terceiro botão, por sua vez tenha o triplo da altura do primeiro. Queremos também que o conjunto dos três os botões ocupem toda a nossa tela. Nosso objetivo encontra-se ilustrado na imagem abaixo: 27/29

28 Para atingir nosso objetivo vamos utilizar o layout_weightpara dar peso à divisão do espaço na tela. Nosso primeiro botão terá peso 1, o segundo terá peso 2 e o terceiro terá peso 3, conforme o código abaixo: <LinearLayout xmlns:android=" android:layout_height="fill_parent" android:orientation="vertical" > <Button android:text="primeiro" android:layout_weight="1" android:layout_height="0dp" <Button android:text="segundo" android:layout_weight="2" android:layout_height="0dp" 28/29

29 <Button android:text="terceiro" android:layout_weight="3" android:layout_height="0dp" </LinearLayout> Lint é uma ferramenta que verifica pequenos erros na construção de layouts como: id duplicado layout duplicados layout não usado texto não externalizado no arquivo strings.xml tamanhos não externalizados no arquivo de dimens.xml outros erros apis de versões superiores usadas em versões inferiores É uma boa ferramenta para verificar se a construção de seu layout está seguindo as regras do Android. O Lint está disponível somente em versões do plugin ADT superiores a versão 14. Para rodar o Lint, basta clicar no menu Window -> Run Android Lint. Ir para o próximo capítulo Começar os exercícios Alura, powered by Caelum A melhor plataforma de ensino online Termos e Política de privacidade Contato 29/29