ANDROID

A plataforma Android é um software para dispositivos móveis, incluindo um sistema

operacional, middleware e aplicativos-chave. Os desenvolvedores podem criar
aplicações para a plataforma usando o Android SDK, sendo que as aplicações são
escritas utilizando a linguagem de programação Java e executado no Dalvik, uma
máquina virtual projetada para uso embutido capaz de rodar em kernel Linux.

Lição 1 - O que é Android?

ANDROID
Android é um software feito para dispositivos móveis que inclui um sistema operacional,
middleware e aplicativos. O SDK fornece as ferramentas e APIs necessárias para começar
a desenvolver aplicações na plataforma Android usando a linguagem de programação
Java.

OPÇÕES:
*Aplicativos Framework permitindo reutilização e substituição de componentes;
*Dalvik - máquina virtual otimizada para dispositivos móveis;
*Navegador código aberto integrado baseado no WebKit;
*Gráficos otimizados alimentado por bibliotecas gráficas 2D; Gráficos 3D baseados no
OpenGL ES 1.0;
*SQLite para armazenamento de dados estruturados;
*Média com suporte para áudio, vídeo e imagens(MPEG4, H.264, MP3, AAC, AMR, JPG,
PNG, GIF);
*Telefonia GSM (dependente de hardware);
*Bluetooth, EDGE, 3G, e WiFi (dependente de hardware);
*Câmera, GPS, bússola, e etc (dependente de hardware);
*Ambiente de desenvolvimento incluindo um dispositivo emulador, ferramentas de
depuração, memória, perfis de desempenho e um plugin para o IDE Eclipse.

ARQUITETURA ANDROID
Figura 1 - Arquitetura

Aplicações
Android irá navegar com um grupo de aplicações, incluindo um cliente de email, programa
SMS, calendário, mapas, navegador, contatos, etc. Todas aplicações são escritas
utilizando a linguagem de programação Java.

Aplicações Framework

Desenvolvedores têm pleno acesso aos mesmos framework API's utilizados por aplicações
complexas. A arquitetura da aplicação foi desenhada para simplificar a reutilização de
componentes, sendo que qualquer aplicativo pode publicar as suas funcionalidades e
qualquer outra aplicação poderá fazer uso das mesmas(mesmo que sujeito a restrições de
segurança impostas pelo framework). Este mesmo mecanismo permite que componentes
sejam substituído pelo usuário.

Todas aplicações de baixo nível são um conjunto de serviços e de sistemas, incluindo:

* Um rico e extensível conjunto de Views que podem ser usadas para construir uma
aplicação, incluindo listas, grides, caixas de texto, botões e mesmo um navegador web;
* Content Providers aplicações que permitam o acesso a dados de outros aplicativos
(como Contatos), ou para compartilhar seus próprios dados;
* Resource Manager fornece acesso a recursos (não codificados) como gráficos e
arquivos de layout;
* Notification Manager permite que todas aplicações exibam avisos personalizados na
barra de estado;
* Activity Manager que gerencia o ciclo de vida das aplicações;

Bibliotecas

Android inclui um conjunto de bibliotecas C / C + + usadas por diversos componentes do

sistema Android. Estas capacidades são expostas aos desenvolvedores por meio da
aplicação framework Android. Algumas das principais bibliotecas são listadas a seguir:

* Sistema C library - Uma biblioteca derivada BSD que é uma implementação do sistema
do padrão C (libc), voltada para dispositivos baseados em Linux;
* Media Libraries - baseado em PacketVideo's OpenCORE, as bibliotecas suportam
reprodução e gravação de muitos formatos populares de áudio e vídeo incluindo MPEG4,
H.264, MP3, AAC, AMR, JPG e PNG;
* Surface Manager - Controla o acesso à exibição do subsistema e de camadas gráficas
2D e 3D de múltiplas aplicações;
* LibWebCore - Um navegador web moderno que torna poderosa a navegação com
Android;
* SGL - Gráficos 2D de baixa camada;
* 3D Libraries - Uma implementação baseada em OpenGL ES 1,0 APIs: Bibliotecas
usadas em aceleração de hardware 3D (quando disponível);
* FreeType - Bitmaps e fontes vetoriais para renderizção;
* SQLite - Leve e poderosa base de dados relacional disponível para todas as aplicações.

Android Runtime

Android inclui um grupo de bibliotecas que fornece a maioria das funcionalidades

disponíveis nas principais bibliotecas da linguagem de programação Java.

Cada aplicação Android roda em seu próprio processo, com a sua própria instância da
máquina virtual Dalvik. O Dalvik VM executa arquivos no Dalvik Executável (.dex), que é
otimizado para usar mínimo de memória. A Dalvik VM baseia-se em kernel Linux para
subjacentes funcionalidade como o encadeamento e gestão de memória de baixo nível.

Linux Kernel

Android invoca Linux versão 2.6 para o sistema central de serviços, tais como segurança,
gestão de memória, gestão de processos, rede e drivers. O kernel também atua como uma
camada de abstração entre o hardware e o resto do software.

Lição 2 - Instalando SDK, Requisitos, Depuração e Dicas

Sistema e Requisitos de Software

Para desenvolver aplicações no Android utilizando o código e ferramentas do Android SDK,

você precisará de um pc e adequado ambiente de desenvolvimento, conforme descrito
 abaixo.

Sistemas Operacionais Suportados

* Windows XP ou Vista;
* Mac OS X 10.4.8 ou posterior (x86 apenas);
* Linux (testado em Linux Ubuntu Dapper Drake).

Ambientes em desenvolvimento suportados

* IDE Eclipse

O Eclipse 3.2, 3.3 (Europa)

O Eclipse JDT Plugin (incluído na maioria dos pacotes Eclipse IDE)
O JDK 5 ou JDK 6 (JRE por si só não é suficiente)
Não é compatível com o Gnu Compiler para Java (gcj)
O Android Development Tools Plugin (opcional)

* Outros ambientes de desenvolvimento ou IDEs

O JDK 5 ou JDK 6 (JRE por si só não é suficiente)

Não é compatível com o Gnu Compiler para Java (gcj)
O Apache Ant 1.6.5 ou posterior para Linux e Mac, 1.7 ou posterior para Windows

Nota: Se JDK já está instalada em seu computador, certificar-se de que ele atende aos
requisitos listados acima. Em particular, note que algumas distribuições Linux podem incluir
JDK 1.4 ou Gnu Compiler para Java, que não são suportados pelo ambiente Android de
desenvolvimento.

Instalação do SDK

Depois de fazer o download do SDK, descompacte o arquivo “.zip” para um local adequado
na sua máquina. Por padrão, os arquivos SDK são desempacotados em um diretório
chamado android_sdk_ <platform> _ <release> _ <build>. O diretório contém os subdiretórios
/tools, /samples e outros.

Anote o nome e local do diretório onde o SDK foi descompactado em seu sistema, você
precisará disto mais tarde, quando for configurar os plugins Android ou utilizar ferramentas
SDK.

Opcionalmente, você pode adicionar o caminho para as ferramentas SDK no seu diretório.
Como mencionado acima, o diretório tools/ está localizado no diretório SDK.

* No Linux, editar o arquivo ~/.bash_profile ou ~/.bashrc. Procure uma linha que define a
variável de ambiente PATH e adicione o caminho completo para o diretório tools/. Se você
não visualizar uma linha definindo o caminho, você pode adicionar um:

export PATH=${PATH}:<seu_sdk_dir>/tools

* Em um computador Mac, procure em seu diretório home pelo .bash_profile e proceda da

mesma forma para Linux. Você pode criar o .bash_profile, se você ainda não o configurou em
sua máquina.
* No Windows, clique com botão direito em Meu Computador e selecione Propriedades. Sob a
guia Avançado, apertar o botão Variáveis de Ambiente e na caixa de diálogo, que aparecerá,
clique duplo no Caminho sob Variáveis de Sistema. Adicione o caminho completo ao diretório
tools/.

Adicionando tools para o seu path permite que você execute Android Debug Bridge (adb) e as
outras linhas de comando tools, sem necessidade de fornecer o caminho completo para o
diretório. Note que, se você atualizar o seu SDK, você deve se lembrar de atualizar suas
configurações PATH para que aponte para o novo local, caso seja diferente.

Instalando o Plugin(ADT) Eclipse

Se você utilizar o Eclipse IDE como o seu ambiente de desenvolvimento de aplicações

Android, você pode instalar um plugin chamado Android Development Tools (ADT), que
adiciona suporte integrado para projetos e ferramentas Android. O ADT Plugin inclui uma
variedade de poderosas extensões que tornam a criação, a execução e depuração de
aplicações Android mais fáceis e rápidas.

Se você não estiver usando o IDE Eclipse, você não precisa fazer o download e instalar o
ADT plugins.

Para baixar e instalar o ADT plug-in siga as etapas a seguir:

1. Inicie o Eclipse e, em seguida, selecione Help > Software Updates > Find and Install....
2. Na caixa de diálogo que é exibida, selecione Search for new features to install em
seguida aperte Next.
3. Aperte New Remote Site.
4. Na caixa de diálogo resultante, digite um nome para o site (ex Android Plugin) e digite isso
como sua URL:

https://dl-ssl.google.com/android/eclipse/

Pressione OK.
5. Agora você deve ver o novo site adicionado à lista de pesquisa. Pressione Finish.
6. Na caixa de diálogo subseqüente Search Results, marque a caixa de seleção Android
Plugin > Eclipse Integration > Android Development Tools e pressione Next.
7. Leia o acordo de licença e, em seguida, selecione Accept para aceitar os termos do
contrato de licença, se for o caso. Pressione Next.
8. Pressione Finish.
9. A ADT plugin não está assinado, você pode aceitar a instalação mesmo assim,
pressionando Install All.
10. Reinicie o Eclipse.
11. Após o reinício, atualize suas preferências do Eclipse para apontar para o diretório SDK:
1. Selecione Window> Preferences... Para abrir o painel preferências. (Mac OS X: Eclipse>
Preferences)
2. Selecione Android do painel esquerdo.
3. Para a localização do SDK no painel principal, pressione Browse... E localize o diretório
SDK.
4. Pressione Apply e, em seguida, OK.

Atualizando o plugin ADT

Para atualizar o ADT plugin para a versão mais recente, siga os seguintes passos:
 1. Selecione Help> Software Updates> Find and Install ....
2. Selecione Search for updates for the currently installed features e pressione Finish.
3. Se alguma atualização para ADT está disponível, selecione e instale.

Alternativamente,

1. Selecione Help> Software Updates> Manage Configuration.

2. Navegue para baixo da árvore de diretório e selecione Android Development Tools
<version>
3. Selecione Scan for Updates sob Available Tasks.

Desenvolvendo aplicações Android no Eclipse

Para começar a desenvolver aplicações Android no Eclipse IDE, você precisa primeiro criar
um projeto e, em seguida, criar um conjunto de configurações. Depois disso, você pode
escrever, executar e depurar sua aplicação.

As seções a seguir fornecem instruções assumindo que você tenha instalado o ADT Plugin no
seu ambiente Eclipse. Se você não tiver instalado o ADT plugin, você deve fazê - lo antes de
usar as instruções abaixo.

Criação de um projeto Android

O ADT Plugin fornece um New Project Wizard que você pode usar para criar um projeto novo
ou de códigos já existentes. Para criar o projeto, siga os seguintes passos:

1. Selecione File> New> Project.

2. Selecione Android> Android Project, e pressione Next.
3. Selecione o conteúdo para o projeto:
* Escolha Create new project in workspace para iniciar um projeto de código novo.
Digite o nome do projeto, do pacote básico, o nome de uma classe única Activity como um
arquivo .java e um nome para ser usado em sua aplicação.
* Escolha Create project from existing source para iniciar um projeto de código existente.
Use esta opção se você quiser construir e executar qualquer uma das amostras de
aplicações incluídas com o SDK. As aplicações de amostra(samples) estão localizadas no
diretório samples/ do SDK.

Navegue para o diretório que contenha o código fonte existente e clique em OK. Se o
diretório conter um arquivo válido Android, a ADT Plugin preencherá o pacote, o Activity, e o
nome da aplicação para você.
4. Pressione Finish.

O ADT Plugin cria essas pastas e arquivos para você de maneira apropriada para o tipo de
projeto:

* src/ A pasta que inclui o arquivo Activity .java.

* res/ A pasta de seus recursos.
* AndroidManifest.xml O xml para o seu projeto.

Criando configuração de lançamento

Antes que você possa executar e depurar sua aplicação no Eclipse, você deve criar uma
configuração lançamento para ele. A configuração de lançamento especifica o projeto a ser
 lançado, o início do Activity, o emulador de opções a ser usado e assim por diante.

Para criar uma configuração para o lançamento da aplicação, siga os seguintes passos:

1. Selecione Run > Open Run Dialog ou Run > Open Debug Dialog conforme o caso;
2. Na lista de tipo de projeto à esquerda, clique com botão direito do mouse em Application
Android e selecione New;
3. Digite um nome para a sua configuração;
4. No guia Android, navegue para o projeto e Activity a iniciar;
5. No guia Emulator, defina as propriedades desejadas tela e da rede, bem como quaisquer
outras opções do emulador de inicialização;
6. Você pode definir opções adicionais no guia Common conforme desejado;
7. Pressione Apply para salvar a configuração de lançamento ou pressione Run ou Debug
(conforme o caso).

Executando e Depurando uma aplicação

Uma vez que você tenha criado o projeto e a configuração de lançamento de seu aplicativo,
você poderá executá-lo ou depurar conforme descrito abaixo.

No menu principal do Eclipse selecione Run> Run ou Run> Debug conforme adequado, para
executar ou depurar o lançamento configuração ativas.

Note que a configuração lançamento ativa é a que foi seleciona mais recentemente no
gerente de configuração Run. Ela não corresponde, necessariamente, à aplicação
selecionada no painel Eclipse Navigation (se houver).

Para definir ou alterar a configuração de lançamento ativa, use gerente de configuração

Run, que você pode acessar através Run> Run Open Dialog ou Run> Open Debug
Dialog.

Executando ou depurando aplicações:

* Inicie o emulador, se ele já não estiver sendo executado;

*Compile o projeto, se houve mudanças desde a última construção e instale a aplicação no
emulador;
*Run inicia a aplicação;
*Debug inicia a aplicação no modo "Espera pelo depurador" e, em seguida, abre a
perspectiva do depurador, atribuindo o depurador Eclipse Java na aplicação.

Desenvolvendo aplicações Android com outras IDEs e ferramentas

A maneira recomendada de se desenvolver uma aplicação Android é usar o Eclipse com o
Android plugins. Este plugin fornece edição, construção, depuração e funcionalidade
integrada direita na IDE. No entanto, a SDK inclui ferramentas que permitem desenvolver
com outros IDEs, incluindo intelliJ (ou se você preferir usar o Eclipse sem o plugin).

Criação de um projeto Android

O Android SDK inclui activityCreator, um programa que gera um número mínimo de
arquivos para seu projeto. Você pode usar o programa para criar um projeto para Android
como um novo código ou de código existente, como as amostras de aplicações incluídas
no SDK. Para Linux e Mac, o SDK fornece activityCreator.py, um script Python. Para o
Windows, activityCreator.bat, um script batch. Independentemente da plataforma, você
pode usar activityCreator da mesma forma.

Para executar activityCreator e criar um projeto Android , siga os seguintes passos:

1. Na linha de comando, mudar para diretório /tools do SDK e criar um novo diretório para
os arquivos dos projetos. Se você está criando um projeto de código existente, mude para
a pasta raiz de sua aplicação.
2. Execute activityCreator. No comando, você deve especificar o nome da classe
completamente qualificado como um argumento. Se você está criando um projeto para o
novo código, a classe representa o nome da sub classe que o script irá criar. Se você está
criando um projeto de código existente, você deve especificar o nome de uma classe
Activity do pacote. Comando opções para o script incluem:
* --out <pasta> que define a saída do diretório. Por padrão, o diretório de saída é o atual.
Se você criou um novo diretório para o projeto arquivos, use esta opção para apontar para
ele.
*-- ide intellij, que gera o projeto de arquivos IntelliJ IDEA no projeto recém criado.

Aqui está um exemplo:

~/android_linux_sdk/tools $ ./activityCreator.py --out myproject

nome.seu.pacote.ActivityName
package: nome.seu.pacote
out_dir: meuprojeto
activity_name: ActivityName
~/android_linux_sdk/tools $

O activityCreator, o script, gera os seguintes arquivos e diretórios (mas não irá

sobrescrever os existentes):

*AndroidManifest.xml: A aplicação de arquiv xml, sincronizada com a classe Activity

específica para o projeto.
*Build.xml: Um arquivo Ant que você pode usar para criar e empacote a aplicação.
*src/your/package/name/ActivityName.java A classe Activity que você especificou na
entrada.
*Sua_activity.iml, sua_activity.ipr, sua_activity.iws [apenas nos flags -ide intelliJ ] arquivos
de projeto intelliJ .
*res/ O diretório que possui os recursos.
*src/ O diretório fonte.
*bin/ O diretório de saída para o script.

Você pode, agora, mover a sua pasta para onde você quiser desenvolvê-la, mas lembre -
se que você terá que usar o programa adb na pasta tools/ para enviar arquivos para o
emulador, assim você terá o acesso entre a sua solução e a pasta tools/.

Além disso, você deve evitar mover o diretório do SDK, uma vez que movê-lo irá quebrar o
link dos scripts construídos.

Construindo uma aplicação Android

Use o arquivo Ant build.xml gerado pelo activityCreator para construir sua aplicação.

1. Se você não tem isso, você pode obter o Ant da homepage Apache Ant. Instale-o e
tenha certeza de que ele está no PATH executável.
2. Antes de chamar Ant, você precisa declarar a variável de ambiente JAVA_HOME para
especificar o caminho onde o JDK está instalado.
Nota: Quando instalar o JDK no Windows, o padrão é instalar "Arquivos de Programa".
Nesse local podem ocorrer erros. O mais adequado seria instalar JDK em um diretório
como por exemplo: c:\ Java \ jdk1.6.0_02.
3. Se você ainda não o fez, siga as instruções para a criação de um novo projeto como fora
descrito anteriormente.
4. Você pode, agora, executar o arquivo de construção Ant simplesmente digitando ant na
mesma pasta onde está o arquivo build.xml do seu projeto. Cada vez que você alterar um
arquivo fonte ou recurso, você deve executar ant novamente e ele empacotará a versão
mais recente da aplicação para você produzir.

Executando uma aplicação Android

Para executar uma aplicação compilada, você irá fazer o upload do arquivo .apk do
diretório /data/app/ no emulador, usando a ferramenta adb como descrito aqui:

1. Inicie o emulador (run <seu_sdk_dir> /tools/emulator da linha de comando).

2. No emulador, navegue até a tela inicial (é melhor não ter que executar o aplicativo
quando você reinstalá-lo sobre o emulador, pressione a tecla Home para navegar para fora
da aplicação).
3. Execute adb install meuprojeto/bin/ <appname>.apk para carregar o executável. Assim,
por exemplo, para instalar a amostra Lunar Lander, navege na linha de comando para
<seu_sdk_dir> /sample /LunarLander e digite ../../tools/adb install bin/LunarLander.apk
4. No emulador, abra a lista de aplicações disponíveis e role para baixo para selecionar e
iniciar a sua aplicação.

Nota: Quando você instalar uma Activity pela primeira vez, você pode ter que reiniciar o
emulador antes que ele apareça na aplicação de lançamento ou outras aplicações podem
chamá-lo. Isso ocorre porque o gestor de pacotes, normalmente, examina completamente
apenas os xml na inicialização do emulador.

Adicionando um Depurador em sua aplicação

Esta seção descreve como exibir um depurador de informações na tela, assim como ligar o
seu IDE à aplicações de depuração em execução no emulador.

Um depurador é naturalmente adicionado quando se usa o Eclipse plugin, mas você pode
configurar outras IDEs para abrirem uma porta que receba informações de depuração.

1. Inicie o Dalvik Debug Monitor Server (DDMS) tool, que funciona como um serviço de
abertura de porta entre o seu IDE e o emulador;
2. Defina configurações opcionais de depuração no seu emulador, tais como bloquear o
início de aplicações para uma atividade até que um depurador seja adicionado. Note que
muitas destas opções de depuração podem ser utilizadas sem o DDMS, como a exibição
de uso da CPU ou taxa de atualização da tela sobre o emulador;
3. Configure seu IDE para anexar à porta 8700 para depuração. Nós incluímos informações
sobre como configurar o Eclipse para depurar o seu projeto.

Configurando IDE para adicionar porta de depuração

DDMS irá atribuir uma porta de depuração específica para cada máquina virtual que se
encontra no emulador. Deve-se também anexar o IDE para esta porta, ou você pode usar
uma porta padrão 8700 para se conectar a qualquer aplicação atualmente selecionada na
lista de máquinas virtuais encontradas.

Seu IDE deve anexar-se à sua aplicação em execução no emulador, mostrando-lhe as

threads e permitindo suspendê-las, verificar seu estado ou definir sua interrupção. Se você
selecionou "Espere o depurador" no painel de configurações de desenvolvimento, a
aplicação será executada quando o Eclipse conectar, assim você terá que definir o ponto
de interrupção que você deseja antes de conectar.

Alterar quer seja o pedido depuração ou a opção "Espere o depurador" faz com que o
sistema mate o aplicativo selecionado se ele estiver sendo executado no momento. Você
pode usar isto para matar suas aplicações se elas estiverem em um estado indesejado,
basta ir em configurações e (des)marcar a caixa.
Dicas de depuração
Quick stack dump

Para obter um "stack dump" do emulador, você pode acessar com o adb shell, utilize "ps"
para encontrar o processo que você quer e, em seguida, "kill -3". O rastro aparecerá no
arquivo de log.

Exibir informações úteis na tela do emulador

O dispositivo pode exibir informações úteis como uso da CPU ou destaques em torno de
áreas redesenhadas. Ative ou desative esses recursos fora da janela de configurações de
desenvolvimento.

Obter informações de estado do sistema pelo emulador (dumpstate)

Você pode acessar informações dumpstate da ferramenta Dalvik Debug Monitor Service.
Veja dumpsys e dumpstate na página do tema adb.

Obter informações de estado da aplicação pelo emulador (dumpsys)

Você pode acessar informações dumpsys da ferramenta Dalvik Debug Monitor Service.
Veja dumpsys e dumpstate na página do tema adb.

Obter informações de conectividade sem fio

Você pode obter informações sobre a conectividade sem fio usando a ferramenta Dalvik
Debug Monitor Service. A partir do menu Device, selecione "Dump radio state".

Logando dados de rastro

Você pode registrar método de chamada e outros dados de rastro em uma atividade
chamando android.os.Debug.startMethodTracing(). Veja executando o Traceview
Debugging Program para mais detalhes.
Logando Dados de Rádio

Por padrão, as informações de rádio não estão conectadas ao sistema (trata - se de muitos
dados). No entanto, você pode ativar o log de dados de rádio usando os seguintes
comandos:

ADB Shell
Logcat - b rádio

Executar adb

Android vem com uma ferramenta chamada adb que oferece várias funcionalidades,
incluindo mover e sincronizar arquivos para o emulador, abertura de portas e executando
um shell UNIX no emulador. Veja usando adb para mais detalhes.

Obtendo telas capturadas do emulador

Dalvik Debug Monitor Server (DDMS) pode capturar screenshots do emulador.

Usar classes auxiliares de depuração

Android provê classes auxiliares de depuração como util.Log e Debug para sua
conveniência.

Construir e instalar uma aplicação Android

Android requer a contrução de ferramentas personalizadas, para que se possa desenvolver

adequadamente os arquivos de recursos e outras partes de uma aplicação Android. Devido
a isso, é preciso ter um ambiente especializado para construir sua aplicação.

Os passos para uma compilação personalizada incluem a compilação dos arquivos XML e
de outros arquivos de recursos, além da criação de um formato de saída adequado. Uma
aplicação Android compilada nada mais é que um arquivo .apk, que é um arquivo
compactado contendo arquivos .dex, arquivos de recurso, dados brutos de arquivos e
outros arquivos. Você pode criar um projeto Android estruturado, quer a partir do zero ou a
partir de arquivos fonte existentes.

Android, atualmente, não suporta o desenvolvimento de aplicações de terceiros em código

nativo C / C + +.

A maneira recomendada de se desenvolver uma aplicação Android é usar o Eclipse com o

Android 'plugin', que fornece suporte para a construção, a execução e depuração de
aplicações Android.

Se você tiver uma outra IDE, o ambiente Android fornecerá ferramentas para construir e
depurar aplicações Android, mas que não são tão integradas quanto à IDE Eclipse.

Remoção de um aplicativo Android

Para remover uma aplicação que tenha sido instalada no emulador, você precisará
executar o adb e apagar o arquivo .apk que você enviou para o emulador quando instalou.
Use "adb shell" e navege para "data/app", em seguida, remova o arquivo usando "rm
your_app.apk".

Dicas para Eclipse

Executando expressões Java arbitrárias no Eclipse

Você pode executar código arbitrário quando pausado em um breakpoint no Eclipse. Por
exemplo, quando em uma função com um argumento String chamado de "zip", você pode
obter informações sobre os pacotes e chamar métodos de classes. Você também pode
invocar métodos estáticos arbitrários: por exemplo, entrando com
"android.os.Debug.startMethodTracing ()" irá iniciar dmTrace.

Abra um código em execução numa janela, selecione Window> Show View> Display no
menu principal para abrir a janela de exibição, um simples editor de texto. Digite sua
expressão, realce o texto e clique no ícone 'J' (ou CTRL + SHIFT + D) para executar o seu
código. O código é executado no contexto da thread selecionada, que deve ser travada em
um breakpoint ou em um ponto de único passo. (Se você suspender a thread
manualmente, você tem o passo único uma vez; isto não funcionará se a thread estiver em
Object.wait ().)

Se você estiver em pausa um breakpoint, você pode simplesmente destacar e executar um

pedaço de código - fonte, pressionando CTRL + SHIFT + D.

Pode - se destacar um bloco de texto dentro do mesmo âmbito, pressionando ALT + SHIFT
+ UP ARROW para selecionar mais amplamente e englobar maiores blocos, ou DOWN
ARROW para selecionar blocos menores.

Aqui estão algumas amostra de entradas e respostas no Eclipse usando a janela de

exibição.

Entrada(input) Resposta(response)
zip (java.lang.String)
/work/device/out/linux-x86-
debug/android/app/android_sdk.zip
zip.endsWith(".zip") (boolean) true
zip.endsWith(".jar") (boolean) false

Você também pode executar código arbitrário quando não estiver em depuração, utilizando
uma página recados("scrapbook"). Verifique na documentação do Eclipse IDE.

Executando DDMS manualmente

Embora a maneira recomendada para se depurar é usar o plugin ADT, você pode
manualmente executar DDMS e configurar o Eclipse para depurar na porta 8700. (Nota:
Certifique - se de que você tenha iniciado DDMS antes).

Lição 3 - Anatomia de uma aplicação Android

Anatomia de uma Aplicação Android

Há quatro módulos de uma aplicação Android:

* Activity(atividade)
* Intents Receiver(receptor pretendido)e Filter
* Service(serviço)
* Content Provider(provedor de conteúdo)

Nem toda aplicação precisa ter todos os quatro, mas a sua aplicação com certeza será
escrita com alguma combinação deles.

Uma vez que você tenha decidido que componentes você utilizará em sua aplicação,
deverá incluí-los em um arquivo chamado AndroidManifest.xml. Este é um arquivo XML
onde você declarará os componentes da sua aplicação e quais são as suas capacidades e
necessidades.

Activity

Ativities são as mais comuns dos quatro módulos Android. Uma Activity é normalmente
uma única tela em sua aplicação. Cada Activity é implementada como uma única classe
que estende a classe base Activity. Sua classe vai exibir uma interface de usuário
composta de Views e eventos a serem respondidos, sendo que a maioria das aplicações
consistem de múltiplas telas. Por exemplo, um aplicativo de mensagem de texto pode ter
uma tela que mostra uma lista de contatos para enviar mensagens para uma segunda tela
que grava a mensagem para o contato escolhido e outras telas para rever as mensagens
antigas ou mudar as configurações. Cada uma destas telas seriam implementadas como
uma Activity. A mudança para uma outra tela será realizada por um início de uma nova
Activity. Em alguns casos, uma Activity pode retornar um valor para a Activity anterior. Por
exemplo, uma Activity que permite ao usuário escolher uma foto que seria retornada pelo
método chamador.

Quando uma nova tela abre, a anterior é pausada e posta em uma pilha de história. O
usuário pode navegar através das telas anteriormente abertas contidas na pilha de história.
Telas também podem ser removidas da pilha de história se necessário. O Android retém
pilha de história para cada aplicação lançada a partir da tela inicial.

Intent e Intent Filters

Android usa uma classe especial chamada de Intent para mover-se de tela para tela. Uma
Intent(intenção) descreve o que uma aplicação deseja fazer. As duas mais importantes
partes da estrutura de dados de Intent são as ações e os dados sobre o qual agir. Valores
típicos de ação são MAIN (porta da frente da Activity), VIEW,PICK,EDIT, etc. Os dados são
expressos como um URI. Por exemplo, para visualizar informações de contato de uma
pessoa, você deve criar uma Intent com a ação VIEW e configurar uma URI que representa
essa pessoa.

Há uma classe relacionada chamada IntentFilter. Embora uma Intent seja efetivamente um
pedido para fazer algo, uma Intent Filter é uma descrição de quais Intent uma Activity (ou
Intent Receiver) é capaz de manusear. Uma Activity, que é capaz de exibir informações de
contato de uma pessoa, pode publicar uma IntentFilter que dirá que ele sabe como lidar
com a ação VIEW quando aplicada a dados representando uma pessoa. Ativities publicam
as suas IntentFilters no arquivo AndroidManifest.xml.

Navegação de tela a tela é realizada por Intents, sendo que para navegar para a frente
uma Activity precisa chamar startActivity (myIntent). O sistema então olha para a Intent
Filters em todas as aplicações instaladas e escolhe a Activity, cujo Intent Filters melhor se
encaixa com myIntent. A nova Activity é informada da Intent, o que provoca que ela seja
lançada. O processo de resolução de Intents acontece em tempo de execução quando
startActivity é chamado, que oferece dois benefícios principais:

* Ativities podem reutilizar funcionalidade de outros componentes simplesmente fazendo

uma solicitação na forma de uma Intent.
* Activities podem ser substituídas, a qualquer momento, por uma nova Activity com um
equivalente IntentFilter.

Intent Receiver

Você pode usar uma IntentReceiver, quando quiser o código em sua aplicação execute em
reação a um evento externo, por exemplo, quando o telefone toca, ou quando a rede de
dados está disponível, ou quando é meia noite. Intent receivers não exibem uma interface
gráfica, embora possa utilizar a NotificationManager para alertar o usuário se algo
interessante aconteceu. Intent receivers são registrados em AndroidManifest.xml, mas você
também pode regista-los com código usando Context.registerReceiver(). Sua aplicação não
precisa estar rodando para que a respectiva Intent receiver seja chamada, já que o sistema
irá iniciar a sua aplicação, se necessário, quando um Intent receiver é acionado.
Aplicações podem também enviar suas próprias trasmissões de Intent aos outros com
Context.broadcastIntent().

Service

Um Service é um código de longa vida e funciona sem uma interface gráfica. Um bom
exemplo disto é uma mídia tocando músicas de um lista. Numa aplicação de media player,
provavelmente seriam uma ou mais Activities que permitiriam ao usuário escolher músicas
e tocá-las. No entanto, a música reproduzida em si não deveria ser manuseada por uma
Activity, pois o usuário espera que a música continue tocando mesmo após navegar para
uma nova tela. Neste caso, o leitor de mídia em atividade pode iniciar um serviço utilizando
Context.startService(), para executar em segundo plano a música, sendo que o sistema irá
manter a reprodução da música até que ela termine (Você pode aprender mais sobre a
prioridade dada aos serviços do sistema de leitura de uma aplicação Android em Android
Application Lifecycle.). Note que você pode conectar-se a um serviço e iniciá-lo caso
ainda não esteja executando com o método Context.bindService(). Quando conectado a um
serviço, você pode comunicar-se com ele através de uma interface exposta pelo serviço da
música permitindo que você possa pausar, retroceder, etc.

Content Provider

Aplicações podem armazenar seus dados em arquivos, base de dados SQLite, ou qualquer
outro mecanismo que tenha sentido de armazenamento. Uma Content Provider, no entanto,
é útil se você desejar que sua aplicação de dados seja compartilhada com outros
aplicativos. A Content Provider é uma classe que implementa um conjunto de métodos
padrão para permitir que outras aplicações armazenem e recuperem o tipo de dados que é
controlado pelo provedor desse conteúdo.

Liçao 4 - Ferramentas, Ciclo de Vida e Filosofia das Aplicações

Ferramentas de Desenvolvimento
O Android SDK inclui uma variedade de ferramentas personalizadas que podem ajudá-lo a
desenvolver aplicações móveis para plataforma Android. A mais importante delas é a
Android Emulator e a Android Development Tools plugin para o Eclipse, mas a SDK
também inclui várias outras ferramentas de depuração, empacotamento e instalação de
suas aplicações no emulador.

Emulador Android

Um dispositivo móvel virtual que pode ser executado em seu computador. Você pode usar
o emulador para desenhar, depurar e testar suas aplicações em um ambiente Android de
execução em tempo real.

Plugin de ferramentas de desenvolvimento Android para a IDE Eclipse

A ADT Plugin acrescenta poderosas extensões para a IDE Eclipse, facilitando criar e
depurar seus aplicativos Android. Isso porque esse plugin lhe permitirá acessar as
seguintes funcionalidades:

* Acessar a outras ferramentas de desenvolvimento Android do interior da IDE Eclipse. Por

exemplo, ADT permite-lhe acessar muitas funcionalidades da ferramenta DDMS como
obter printscreens, gerenciamento de abertura de portas, definir pontos de interrupção e
visualizar threads e informações de processo diretamente do Eclipse;

* Provê um New Project Wizard, que ajuda você criar rapidamente e configurar a base de
todos os arquivos que você precisará em uma nova aplicação Android;

* Automatiza e simplifica o processo de construção da sua aplicação Android;

* Fornece um editor de código Android que ajudará você a escrever um XML válido para o
seu Android.

Dalvik Debug Monitor Service (ddms)

Integrada com Dalvik, a personalizada VM(máquina virtual) da plataforma Android, permite

- lhe gerir processos em um emulador ou dispositivo e auxilia na depuração. Você pode
usá-la para matar processos, selecionar um processo específico para depurar, gerar rastro
aos dados, visualizar informações, tirar fotos do emulador ou do dispositivo e muito mais.

Android Debug Bridge (adb)

A ferramenta Adb permite que você instale sua aplicação(arquivos .apk ) em um emulador
ou dispositivo e que acesse o emulador ou dispositivo a partir de uma linha de comando.
Você também pode usá-la para ligar o depurador padrão à um código de aplicação,
rodando em um emulador ou dispositivo Android.

Android Asset Packaging Tool (aapt)

A ferramenta aapt permite que você crie arquivo .apk contendo os binários de recursos de
aplicações Android.

Android Interface Description Language (aidl)

Permite-lhe gerar código para uma interface de interprocesso, como um serviço que você
possa utilizar.

Sqlite3

Incluído como uma conveniência, esta ferramenta permite-lhe acessar dados de arquivos
SQLite criados e utilizados por aplicações Android.

Traceview

Esta ferramenta produz análise com visualização gráfica dos rastros de dados registrados
que você pode gerar a partir de sua aplicação Android.

Mksdcard

Ajuda você a criar um disco imagem que você pode usar com o emulador, para simular a
presença de um cartão externo de armazenamento (como um cartão SD).
DX

A ferramenta dx reescreve bytecodes .class em bytecodes Android(armazenados em

arquivos .dex).

ActivityCreator

Um script que gera arquivos Ant que você pode usar para compilar suas aplicações
Android. Se você estiver desenvolvendo no Eclipse com o ADT plugin, você não precisará
usar esse script.

Ciclo de vida de uma aplicação Android

Na maioria dos casos, as aplicações Android rodam em seu próprio processo Linux. Este
processo é criado para a aplicação quando alguns de seus códigos precisarem ser
executados e, ainda, continuarem funcionando até que eles já não sejam necessários e
que o sistema precise de memória para uso em outros aplicativos.

Uma característica importante e não tão usual de Android é que o tempo de vida de uma
aplicação não é diretamente controlado pela própria aplicação. Ao invés disso, ele é
determinado pelo sistema, através de uma combinação das partes da aplicação que o
sistema sabe que está funcionando, de como essas coisas são importantes para o
utilizador e de quanta memória global encontra-se disponível no sistema.

É importante que desenvolvedores de aplicação entendam como diferentes componentes

da aplicação (em especial Ativity, Service, e IntentReceiver) causam impacto sobre o
tempo de vida no processo de uma aplicação. Não utilizar estes componentes
corretamente pode fazer com que o sistema mate a aplicação enquanto ela estiver fazendo
algo importante.

Um exemplo comum de um ciclo de vida de um processo é o IntentReceiver que inicia a

thread(tarefa) quando recebe uma Intent em seu método onReceiveIntent() e, em seguida,
retorna da função. Uma vez retornado, o sistema considera que IntentReceiver deixou de
estar ativo e, por conseguinte, hospedar o processo não é mais necessário (a menos que
outros componentes da aplicação estejam ativos). Assim, ele pode matar o processo a
qualquer momento para recuperar memória, encerrando a thread que está sendo
executado na mesma. A solução para este problema é iniciar um serviço a partir da
IntentReceiver, de modo que o sistema saiba que ainda há muito trabalho a ser feito no
processo ativo.

Para determinar quais processos devem ser mortos quando há pouca memória, o Android
coloca-os em uma "hierarquia de importância", baseada nos componentes em execução e
no estado desses componentes. Estas são as ordens de importância:

1. Um processo, em primeiro plano, mantém uma Activity na parte superior da tela em que
o usuário está interagindo (seu método onResume() foi chamado) ou um IntentReceiver
que está sendo executado no momento (o seu método onReceiveIntent() está executando).
Haverá apenas alguns desses processos no sistema e eles só serão mortos como um
último recurso, caso a memória esteja tão baixa que nem mesmo esses processos possam
continuar a funcionar. Geralmente, neste ponto o dispositivo atingiu um estado de
paginação da memória, então essa ação de matar o processo é necessária de modo a
manter a interface do usuário respondendo.

2. Um processo visível tem uma Activity que é visível para o usuário na tela, mas não no
primeiro plano(seu método onPause() foi chamado). Isto pode ocorrer, por exemplo, se a
atividade de primeiro plano for exibida com a aparência de diálogo que permite que a
Activity anterior seja vista por trás dela. Tal processo é considerado extremamente
importante e não será morto a menos que isso seja necessário para que todos os
processos de primeiro plano continuem sendo executados.

3. Um processo de serviço é aquele que mantém um Service que tenha sido iniciado com o
método startService(). Embora estes processos não sejam diretamente visíveis para o
usuário, eles estão geralmente fazendo coisas que importam para o usuário (como mp3
sendo tocadas em segundo plano, upload e download de dados pela rede), então o sistema
irá sempre manter esses processos em execução, a menos que não haja bastante Memória
para manter todos os processos visíveis e de primeiro plano.

4. Um processo de segundo plano é aquele que tem uma Activity que não está visível para
o usuário (seu método onStop() foi chamado). Estes processos não têm impacto direto
sobre a experiência do usuário. O sistema pode matar esses processos a qualquer
momento para recuperar memória de um dos três tipos de processos anteriores.
Normalmente, existem muitos destes processos executando, então eles são mantidos em
uma lista LRU para garantir que o processo mais recentemente visto pelo usuário seja o
último a ser morto quando está baixa a memória.

5. Um processo vazio é aquele que não possui qualquer componente de aplicação activo. A
única razão para manter tal processo é tê-lo em cache(escondido), para melhorar o tempo
de inicialização na próxima vez que um componente da aplicação precisar ser executado.
Sendo assim, o sistema irá matar muitas vezes estes processos, a fim de manter o
equilíbrio geral dos recursos do sistema.

Ao decidir a forma de classificar um processo, o sistema escolhe o nível mais importante

de todos os componentes atualmente ativos no processo, segundo a hierarquia descrita
acima.

Filosofia para Design de aplicações Android

O processo de aprendizagem de como construir aplicações para uma nova API é

bastante semelhante, ainda que as próprias plataformas sejam diferentes.
Geralmente, há duas fases: Na primeira, você aprende como usar as APIs para
fazer o que você quiser que elas façam, mais tarde, você aprende as nuanças da
plataforma. Em outras palavras, primeiro é mostrado como você pode construir
aplicações, depois como você deve construi-las.

Nessa segunda fase de aprendizagem do caminho certo para construir aplicações,

pode-se levar muito tempo e, freqüentemente, significa cometer erros e aprender
com eles. Bom, isso não é um processo muito eficiente, por isso esta página e os
links abaixo destinam-se a dar-lhe uma pequena ajuda.

Saiba que aplicações bem sucedidas irão oferecer uma excelente experiência ao
usuário final. Enquanto a equipe Android criou um núcleo de sistema sólido, a
maior parte da experiência do usuário será proveniente da interação do próprio
usuários com suas aplicações.

Uma aplicação que proporciona uma excelente experiência para o usuário tem três
características fundamentais: é rápida, interativa e é sem descontinuidades.
Naturalmente, cada plataforma desde o início da computação já tem,
provavelmente, essas mesmas três qualidades em algum momento. No entanto,
cada plataforma as alcança de forma diferente, sendo que as informações abaixo
explicam como seus aplicativos podem alcançá-las em Android.

Rapidez
Uma aplicação Android deve ser rápida ou talvez seja mais correto dizer que ela
deve ser eficiente. Há uma tendência no mundo da computação estes dias para
supor que Lei de Moore irá resolver todos os nossos problemas eventualmente.
Quando se trata de aplicações embutidas, no entanto, a Lei de Moore é um pouco
mais complicada.

A lei de Moore realmente não se aplica aos dispositivos móveis da mesma forma
que as aplicações para desktop e servidor. Ela é realmente uma lei sobre
transístor de densidade. Ou seja, diz-se que você também pode compactar mais
circuitos em um determinado tamanho de chips com o passar do tempo. Para
aplicações desktop e servidor, isto significa que você pode empacotar mais
"velocidade" em um chip de aproximadamente o mesmo tamanho, o que resultou
no aumento substancial do desempenho. Para aplicações embutidas, como
telefones celulares, no entanto, a lei de Moore é normalmente utilizada para fazer
chips menores. Ou seja, a tendência é usar o aumento da densidade para fazer o
mesmo chip menor e consumindo menos energia, a fim de tornar telefones
pequenos e alongar a duração das baterias. Como resultado, dispositivos
embutidos como telefones estão aumentando em velocidade muito mais lenta do
que sistemas de computador.

Por isso, é tão importante escrever códigos cada vez mais eficientes: não se pode
presumir que telefones terão a mesma velocidade de desenvolvimento que
servidores e desktops, mas de uma maneira geral, escrever códigos eficientes
significa manter a alocação de memória em um valor mínimo, evitando certas
linguagens de programação e expressões que possam prejudicar o desempenho.
Em termos de orientação a objetos, a maior parte deste trabalho é efetuado no
nível dos métodos.

Interativo

É possível escrever um código de desempenho extremamente rápido e eficaz,

porém ele terá um terrível defeito: a falta de interação com o usuário de forma
satisfatória. Estes tipos de aplicações não são suficientemente interativas. Porém,
as que são demasiadamente interativas costumam ser lentas, pesadas, podendo
congelar por períodos significativos ou demorar muito para processar a entrada.
Em termos Android, aplicações que não são suficientemente interativas irão
freqüentemente fazer com que o sistema emita a temida mensagem "Not
Responding Application" (ANR).

Geralmente, isso acontece se sua aplicação não responder às informações

fornecidas pelo usuário. Por exemplo, se a sua aplicação bloquear algumas
operações de entrada e saída (freqüentemente uma rede acesso), então a
aplicação principal (main thread) não será capaz de processar eventos recebidos
do usuário. Depois de um tempo, o sistema irá concluir que a sua aplicação está
em espera e dará ao usuário a opção de matá-la. Da mesma forma, se a sua
aplicação gastar muito tempo construindo uma estrutura elaborada na memória ou
talvez computando os próximos passos em um jogo, então, novamente o sistema
irá concluir que sua aplicação está em espera e dará ao usuário a opção de matá-
la. É sempre importante para certificar-se de que estes cálculos são eficientes
utilizando as técnicas acima, mas mesmo os mais eficientes códigos ainda levam
tempo para serem executados.
 Em ambos os casos, a correção é geralmente para criar uma pequena thread que
faça a maior parte dos seus trabalhos. Isto mantém a main thread (que dirige o
loop da interface com usuário) executando e impede que o sistema conclua que
seu programa congelou.

Sem descontinuidade

Mesmo que a sua aplicação seja rápida e interativa, ela ainda pode irritar os
usuários. Um exemplo comum é um processo de fundo (como um Android Service
ou IntentReceiver) que aparece numa interface gráfica em resposta a algum
evento. Isto pode parecer inofensivo e desenvolvedores, freqüentemente,
assumem que isto é correto, porque eles passam a maior parte do seu tempo
testando e utilizando a sua própria aplicação. No entanto, o modelo de aplicação
Android é construído explicitamente para permitir que os usuários alternem
fluentemente entre aplicações. Isto significa que quando um processo, em
segundo plano, acende uma UI, o usuário poderá ir para outra parte do sistema,
fazendo outras coisas tais como atender uma ligação. Imagine se o serviço SMS
abrir uma caixa de diálogo cada vez que uma mensagem de texto entrar. Isso iria
irritar os usuários e é por isso que o padrão Android é utilizar notificações para
tais eventos, dando mais controle ao usuário.

Esse é apenas um exemplo, há muitos mais. Por exemplo, se uma Ativity não
implementar corretamente o onPause () e outros métodos, isso vai resultar em
perda de dados. Ou, se sua aplicação expor dados destinados a serem utilizados
por outras aplicações, você deve fazê-lo através de um ContentProvider, utilizando
um banco de dados, por exemplo.

O que esses exemplos têm em comum é que eles envolvem coperação entre o
sistema e outras aplicações. O sistema Android foi concebido para tratar
aplicações como uma espécie de federação de componentes vagamente acoplados,
em vez de pedaços de código acoplados. Isto permite-lhe como o desenvolvedor
visualizar todo o sistema apenas como uma federação ainda maior desses
componentes. Isso permite-lhe integrar-se limpa e harmonicamente com outros
aplicativos, por isso você deve projetar seu próprio código para retornar o favor.

Glossário Android

.apk extensão

Essa é a extensão para um pacote de arquivos Android, que geralmente contém todos os
arquivos relacionados a uma única aplicação Android. O próprio arquivo compactado é uma
coleção de um arquivo AndroidManifest.xml, código de aplicação (. Dex arquivos), arquivos
de recurso e outros arquivos. Um projeto é compilado em um único arquivo ".apk".

.dex extensão
Programas Android são compilados em arquivos .dex (Dalvik Executável), que estão
compactados em um único arquivo .apk no dispositivo. Arquivos .dex podem ser criados
por aplicações compiladas traduzidas automaticamente e escritas na linguagem de
programação Java.

Action

Uma descrição de algo que uma Intent sender irá realizar. Uma ação é uma string de valor
atribuído a um Intent. Strings de Action podem ser definidas pelo Android ou por uma
terceira parte desenvolvedora. Por exemplo, android.intent.action.VIEW para uma URL
Web, ou com.example.rumbler.SHAKE_PHONE para uma aplicação feita sob encomenda
para vibrar o telefone.

Activity

A única tela de um aplicativo, com suporte à código Java, derivados da classe Activity.

adb

Android Debug Bridge, uma aplicação para depurador em linha de comando depuração
enviado juntamente com o SDK. Ele fornece ferramentas para navegar o dispositivo, copia
ferramentas no dispositivo e encaminha portas para depuração.

Application

Uma coleção de uma ou mais atividades, serviços, escutas e Intent receivers. Uma
aplicação tem uma única manifestação e é compilada em um único arquivo .apk no
dispositivo.

Content Provider

A classe construída sobre ContentProvider que manipula os conteúdos de consulta a

stringss de um formato específico para retornar dados em um formato também específico.
Content URI

Um tipo de URI.

Dalvik

O nome da máquina virtual Android. O Dalvik VM é apenas um interpretador que executa

arquivos no formato Dalvik Executável (.dex), um formato que é otimizado para o
armazenamento eficiente e mapeamento de memória em execução. A máquina virtual é de
registo base, podendo executar aulas compiladas por um compilador linguagem Java que
foram transformadas em seu formato nativo usando o incluiu "dx" ferramenta. O VM roda
no topo do Posix compatível com os sistemas operacionais, que se baseiam sobre a
funcionalidade subjacente (tais como o encadeamento e baixo nível memória gestão). O
Dalvik núcleo classe biblioteca destina - se a fornecer uma base para o desenvolvimento
familiarizado com os utilizados para programação com Java Standard Edition, mas é
orientado especificamente para as necessidades de um pequeno dispositivo móvel.

DDMS

Dalvik Debug Monitor Service, uma GUI para depuração de aplicação que vem junto com o
SDK. Fornece tela de captura, log dump e etcs. Veja usando o Dalvik Debug Monitor
Server para obter mais informações sobre este programa.

Drawable

Um recurso visual compilado que pode ser utilizado como fundo, título ou outra parte da
tela. É compilado em uma subclasse android.graphics.drawable.

Intent

Uma classe Intent, que contém vários campos descrevendo o que um chamador deveria
fazer. O chamador envia esta intenção para um "resolvedor de intenções" Android que olha
através de filtros a intenção de todas as aplicações para encontrar a atividade(activity)
mais adequada para lidar com esta intenção(intent). Os campos das Intent incluem a ação
desejada, uma categoria, uma seqüência de dados, o tipo MIME dos dados, um tratamento
classe e outras restrições.

Intent Filter

Atividades e intenções receptores incluem um ou mais filtros em seus manifestos para

descrever que tipo de intenções ou mensagens que eles podem manter ou desejam
receber. Uma intenção filtro enumera um conjunto de requisitos, tais como tipo de dados, a
ação solicitada e URI formato, que as intenções ou mensagens devem cumprir. Para
Atividades, android pesquisa com a mais estreita correspondência válida entre as
intenções e as atividades filtro. Para mensagens, android vai encaminhar uma mensagem
para todos os receptores com correspondência intenção filtro.

Intent Receiver

Uma classe de aplicação que ouve mensagens difundidas pelo chamado de

Context.broadcastIntent().

Layout Resource

Um arquivo XML que descreve o layout de uma tecla Activity.

Manifesto

Um arquivo XML associado com cada aplicativo que descreve as diferentes activities, filtros
intent, serviços e outros itens que ela expõe.

Nine-patch / 9-patch / Ninepatch image

Um recurso de bitmap de tamanho variável que pode ser usado para outros fundos ou
imagens no dispositivo.

Query String
Um tipo de URI. Veja a entrada URI.

Resource

Um XML de usuário fornecido, bitmap ou outro arquivo, entrou em um processo de

contrução do aplicativo, que mais tarde podem ser carregados a partir de código. Andróid
pode aceitar recursos de vários tipos. Aplicação-definidos recursos devem ser
armazenados no res / subpastas.

Service

Uma classe que é executada em segundo plano para executar várias ações persistentes,
como a reprodução de música ou atividade de monitoramento de rede.

Theme

Um conjunto de propriedades (texto tamanho, a cor, e assim por diante) empacotados

juntos para definir diferentes configurações default display. Andróide fornece alguns temas
padrões, enumerados no R.style (começando com "Theme_").

URIs

Andróide usa strings URI tanto para solicitar dados (por exemplo, uma lista de contatos)
quanto para requerer ações (por exemplo, abrir uma página da Web em um navegador).
Ambas são string válidas URI, mas têm valores diferentes. Todos os pedidos de dados
devem começar com a string "content://". Strings de Ação são válidas URIs que podem ser
tratadas adequadamente por aplicações no dispositivo. Por exemplo, uma URI começando
com "http://" será manuseada pelo navegador.