terça-feira, 23 de abril de 2013

Primeiros passos - 4ª parte, Ajustando o resultado final.


O esboço é atualmente definido para ambos os componentes da interface gráfica EditText e Button que são tão grandes quanto à necessidade de encaixar seu conteúdo, como mostrado a seguir.
 Isto funciona bem para o botão, mas não tão bem para o campo texto, afinal o usuário pode digitar algo maior. Então, seria ideal preencher a largura de tela não utilizada com o campo texto. Você pode fazer isto dento do  LinearLayout com a propriedade tamanho, que você pode especificar com o atributo android:layout_weight.
O valor tamanho é o numero que especifica a quantidade de espaço restante que cada área de visão irá consumir, relativo à quantidade consumida pelas visualizações derivadas. Isto funciona como a quantidade de ingredientes na receita de bebida: “2 partes de vodka, 1 parte de licor de café”. Por exemplo se você der o peso de 2 para um e o peso de para outro, a soma será 3, assim a primeira área de visão ocupa 2/3 do espaço restante o a segunda preenche o resto.  Se você adicionar uma terceira área de visão e der o peso de 1, a primeira área de visão (com peso 2) agora pega 1/ 2 dos espaços, enquanto o restante ocupa 1/4 cada um.
O Tamanho padrão para todas as visualizações é 0, então se especificar qualquer peso, então se você especificar qualquer valor de tamanho maior que 0 para apenas uma visão, então esta área de visão irá ocupar todo o espaço restante. Então para preencher o espaço restante do seu esboço com o elemento EditText, de o tamanho de 1 e deixe o botão sem tamanho.
    <EditText

        android:layout_weight="1"

        ... />
Em ordem para melhorar a eficiência do seu esboço quando você especificar o tamanho, você deve mudar a largura do seu EditText para zero (0dp). Definindo a largura com zero melhora a desempenho do esboço devido ao uso de "wrap_content" uma vez que a largura utiliza o sistema para calcular uma largura que em si é irrelevante devido ao valor do tamanho requerido por outro calculo de largura para preencher o espaço remanescente.
    <EditText

        android:layout_weight="1"

        android:layout_width="0dp"

        ... />
Abaixo  mostra o resultado de assinalar todo o tamanho para o elemento  EditText.


Aqui está como o arquivo de esboço deve ficar :
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="horizontal">

    <EditText android:id="@+id/edit_message"

        android:layout_weight="1"

        android:layout_width="0dp"

        android:layout_height="wrap_content"

        android:hint="@string/edit_message" />

    <Button

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="@string/button_send" />

</LinearLayout>

Este esboço é aplicado por padrão pela classe Activity que a ferramenta do SDK gera quando você cria o projeto, assim você pode rodar o aplicativo e ver o resultado:
·         No Eclipse, clique em Run  na barra de ferramentas.

Continue para a próxima postagem para aprender como você pode responder ao pressionamento de um botão, ler o conteúdo do texto e iniciar outra atividade.

domingo, 21 de abril de 2013

Primeiros passos - 3ª parte, Adicionando texto e botão


Adicionar um Campo Texto


Quando você precisa adicionar texto na interface para o usuário, você deve sempre especificar cada texto como um recurso. Recursos de texto permitem você gerenciar todo o texto da interface em apenas um só local, o que facilita a atualização de conteúdo.Separar o texto permite que você crie aplicativos para diferentes idiomas ao prover definições alternativas para cada recurso de texto.
Por padrão, seu projeto Android deve incluir o arquivo texto de recurso em  res/values/strings.xml. Adicionar um novo texto nomeado "edit_message" e definir o valor para “Entre a mensagem”( Você pode apagar o texto "hello_world" ).
Enquanto você estiver neste arquivo, também adicione o texto “Enviar” para o botão que em breve você adicionará, chamado "button_send".O arquivo strings.xml resultante irá aparecer assim:
<?xml version="1.0" encoding="utf-8"?>

<resources>

    <string name="app_name">Meu Primeiro Ap</string>

    <string name="edit_message">Entre a mensagem</string>

    <string name="button_send">Enviar</string>

    <string name="action_settings">Configuração</string>

    <string name="title_activity_main">MainActivity</string>

</resources>
Para maiores informações sobre o uso de texto no seu aplicativo em outros idiomas, consulte a classe Suportando Diferentes Dispositivos.

Adicionar um Botão



Agora adicione ao esboço um <Button> , imediatamente seguindo o elemento <EditText>:
    <Button

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="@string/button_send" />
A altura e largura são definidas para "wrap_content" para que o botão seja tão grande quanto for necessário pra encaixar o texto do botão. Este botão não precisa do atributo android:id, uma vez que não há referencia no código principal de atividade.

sábado, 20 de abril de 2013

Primeiros passos - 2ª parte, Recurso do objeto e atributo


Para criar um campo texto editável pelo usuário, adicione um elemento  <EditText> dentro de  <LinearLayout>.
Como todo objeto View, você deve definir certos atributos para especificar as propriedades do objeto EditText. Aqui está como você deve declarar dentro do elemento  <LinearLayout>:
    <EditText android:id="@+id/edit_message"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:hint="@string/edit_message" />

Sobre os recursos do objeto

Um recurso de objeto é apenas um inteiro único nomeado para ser associado com o recurso do aplicativo, tais como um bitmap, um arquivo de layout(esboço) ou uma string(texto).
Cada recurso tem de corresponder ao seu recurso de objeto definido dentro do arquivo  gen/R.java de seu projeto. Você pode usar o nome na classe R para referenciar seu recurso, tais como quando você  precisa especificar um valor de string para o atributo  android:hint. Você também pode criar arbitrariamente IDs de recurso para associar com a visualização usando o atributo android:id, que permite a você referenciar uma visão do outro código.
A ferramenta do SDK gera  R.java cada vez que compilar seu aplicativo. Você nunca deve modificar este arquivo manualmente.
Para maiores informações, leia esta guia para Gerar Recursos.

 

Sobre os atributos

Este prove um identificador único para a visualização, o qual você pode usar para referenciar o objeto no código do seu aplicativo, tais como ler e manipular o objeto(que você irá ver numa futura postagem).
O sinal arroba(@) é requerido quando você for referenciar qualquer recurso do objeto no XML. Seguido do tipo de recurso(neste caso o id), a barra, e então o nome do recurso (edit_message).
O sinal mais (+) antes do tipo do recurso, somente é requerido quando você definir o ID do recurso pela primeira vez. Quando você compilar o aplicativo, a ferramenta de SDK o ID do nome para criar um novo ID de recurso no arquivo gen/R.java em seu projeto que se refere ao elemento EditText. Uma vez que o ID de recurso seja declarado desta forma, outras referencias ao ID não necessitaram do sinal de mais. Usando sinal de mais é necessário somente quando se especifica um novo recurso do ID e desnecessário para recursos concretos como strings e layouts. Veja o texto anterior a este para maiores informações sobre recursos de objeto.
Ao invés de especificar tamanhos para largura e altura, o valor "wrap_content"  especifica que uma visualização deve ser tão grande quanto for preciso para encaixar seu conteúdo para ver. Se você ao invés disso usar "match_parent", então elemento EditText irá preencher a tela, uma vez que equipara a tamanha origem de LinearLayout. Para maiores informações veja o guia de Layouts (Esboços).
Este é texto padrão a se mostrado quando o campo texto estiver vazio, Ao invés de usar uma string diretamente no código como valor, o valor  "@string/edit_message" referencia o recurso do texto definido em um arquivo separado. Se isto referencia um recurso concreto(não apenas um identificador), não precisa do sinal  de mais. De qualquer forma, uma vez que não tenha sido definido o recurso do texto ainda, você irá ver o compilador indicar erro inicialmente. Você irá consertar na próxima seção quando definirmos o texto.
Nota: Este recurso de texto tem o mesmo nome que o ID do elemento: edit_message. De qualquer maneira, referencias para recurso fazem parte do trabalho do tipo de recurso(tais como id ou string), assim usar o mesmo nome não irá causar colisões.

sexta-feira, 19 de abril de 2013

Primeiros passos - 1ª parte, Criando uma simples interface


A interface gráfica do usuário para um aplicativo Android é construída usando a hierarquia dos objetos  View e ViewGroup. O objeto View geralmente é um aplicativo de interface de usuário com  botões  ou textos e objetos  ViewGroup são contêineres invisíveis que definem como a visão de derivados é apresentada tais como grades ou listas verticais.
Android fornece um vocabulário XML que correspondem as subclasses de View e ViewGroup para que você possa definir sua interface no XML utilizando a hierarquia de elementos para interface do usuário.
Recomenda-se a leitura de:
·         Layouts


Layouts Alternativos

Declarando sua o esboço da interface do usuário no XML ao invés do código em execução tem varias vantagens, mas é especialmente importante para que você crie diferentes layouts para diferentes tamanhos de tela. Por exemplo, você pode criar duas versões de um esboço e informar ao sistema para usar um em telas “pequenas” e outro em telas “grandes”. Para maiores informações, veja a classe para.
Nesta postagem, Você irá criar um esboço em XML que irá incluir um campo texto e um botão. Na lição seguinte, você repondera quando o botão for pressionado ao enviar o conteúdo do campo texto para outra ação.

Criando um layout linear



Abra o arquivo activity_main.xml do diretório res/layout/.
Nota:  No Eclipse, quando você abre o arquivo de esboço, será mostrado primeiramente o editor de esboço gráfico. Este editor que irá ajudar a construir o esboço com a ferramenta WYSIWYG. Para está postagem, você irá trabalhar diretamente com o XML, portanto clique na guia activity_main.xml no topo da tela para abrir o editor XML.
O modelo base BlankActivity que você escolheu quando começou a criar este projeto inclui o arquivo activity_main.xml com visão de raiz RelativeLayout  e visão derivada TextView.
Primeiro, apague o elemento <TextView> e mude o elemento <RelativeLayout>  para o elemento  <LinearLayout>. Então adicione o atributo android:orientation e defina para "horizontal". O resultado será semelhante a isto:
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="horizontal" >

</LinearLayout>
LinearLayout é um visualizador de grupo( como uma subclasse de ViewGroup) que direcionar a visualização derivada em uma orientação vertical ou horizontal, como especificado  pelo atributo android:orientation. Cada derivação de LinearLayout aparece na tela na mesma ordem em que aparece no XML.
Outros dois atributos, android:layout_width e android:layout_height, são necessários para todas as visualizações para conseguir especificar seu tamanho.
Devido à LinearLayout ser a fonte do esboço, deve preencher toda a área da tela disponível do aplicativo, definindo a largura  e a altura com "match_parent". Este valor declara que a visualização deve expandir seu tamanho e altura para equiparar com a largura e altura da visualização de origem.
Para maiores informações sob as propriedades do esboço, veja este guia de Layout.

sábado, 13 de abril de 2013

Usando o andador, rodando o seu aplicativo



Iremos aprender a rodar em um dispositivo real e a rodar no emulador, se você seguiu a postagem anterior para criar um projeto Android, que inclui a configuração padrão para os arquivos fontes do “Hello World” que permitirão o aplicativo ser rodado imediatamente.

Como você irá rodar seu aplicativo depende de duas coisas: possuir um dispositivo real do Android ou usando o emulador com o Eclipse. Nesta lição iremos mostrar como instalar e executar seu aplicativo num dispositivo real e no emulador do Android, em ambos os casos usando o Eclipse.

Antes de executar o seu aplicativo, você deve compreender alguns diretórios e arquivo no projeto do Android:
AndroidManifest.xml
O arquivo manifest  descreve as características fundamentais do aplicativo e define cada um de seus componentes. Você irá aprender sobre as varias declarações neste arquivo conforme for avançando nos tutoriais.
Um dos mais importantes elementos que seu manifesto deve incluir é o elemento <uses-sdk> . Este declara a compatibilidade de seu aplicativo com as diferentes versões do Android usando os atributos android:minSdkVersion e android:targetSdkVersion. Para o seu primeiro aplicativo, deverá se parecer com isto:
<manifest xmlns:android="http://schemas.android.com/apk/res/android" ... >
   <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="17" />
   ...
</manifest>
Você sempre deve definir a android:targetSdkVersion maior possível e testar seu aplicativo com a versão de plataforma correspondente. Para maiores informações leia Suporte a diferentes versões de plataforma.
src/
Diretório para os arquivos fontes principal, por padrão deve incluir uma classe Activity que roda quando seu aplicativo for executado com ícone da aplicação.
res/
Contem diversos subdiretórios para os recursos do aplicativo. Aqui estão alguns:
drawable-hdpi/ Diretório para objetos desenháveis (como bitmaps) que são especificados para telas de alta-densidade(hdpi). Outros diretórios desenháveis contem recursos específicos para outras densidades de tela.
layout/ Diretório para arquivos em que você define a interface do aplicativo.
values/ Diretório para os vários arquivos XML que contem a coleção de recursos, como strings e definições de cores.
Quando você criar e rodar o seu aplicativo padrão do Android, a classe  Activity inicia e carrega o arquivo que diz "Hello World." O resultado não é muito empolgante, mas é importante que você compreenda como rodar seu aplicativo antes de começar a desenvolver.
Rodando em um dispositivo

Caso você tenha um dispositivo com Android, isto é o que você deve fazer para instalar e rodar seu aplicativo:

1.    Conecte seu dispositivo a sua maquina de desenvolvimento com o cabo USB. Caso esteja desenvolvendo no Windows, será preciso instalar o driver USB apropriado para o seu dispositivo. Para ajudar a instalar os drivers, veja o documento OEM USB Drivers.
2.    Habilite o debug pela USB (USB debugging) no seu dispositivo.
o    Na maioria dos dispositivos rodando Android 3.2 ou anterior, você pode encontrar a opção em Settings > Applications > Development.
o    Para Android 4.0 e mais recentes, fica em Settings > Developer options.
o    Nota: Para o Android 4.2 e mais recentes, Developer options fica oculto por padrão. Para tornar disponível, vá para Settings > About phone e aperte Build number sete vezes. Retorne para a tela anterior e encontre Developer options.
Para executar o aplicativo a partir do Eclipse:

1.    Abra um dos arquivos do projeto e clique em  Run  na barra de ferramentas.
2.    Em Run as uma janela irá aparecer, selecione Android Application e clique OK.
Eclipse instalará o aplicativo no seu dispositivo que está conectado e inicia-lo.
Rodando no Emulador

Para rodar o aplicativo no seu emulador, você precisa primeiro criar um  Android Virtual Device (AVD). Um AVD é a configuração para dispositivo do emulador de Android que permite você modelar para diferentes dispositivos.

Para criar um AVD:

1.    Execute o Android Virtual Device Manager , no Eclipse, clique em Android Virtual Device Manager na barra de ferramenta.
2.    No painel do Android Virtual Device Manager, clique em New.
3.    Preencha os detalhes para uma plataforma desejada, o tamanho do cartão SD e um skin (HVGA é o padrão).
4.    Clique em Create AVD.
5.    Selecione um novo AVD do Android Virtual Device Manager e clique em Start.
6.    Depois de o emulador iniciar, libere a tela do emulador.
Para rodar o aplicativo a partir do Eclipse:

1.    Abra um dos arquivos do projeto e clique em Run  a partir da barra de ferramentas.
2.    Em Run as uma janela irá aparecer, selecione Android Application e clique OK
Eclipse instala o aplicativo no seu AVD e o inicia. É assim que cria e roda seu aplicativo Android no Emulador! Na próxima postagem começaremos o desenvolvimento.