Android
Android: um novo paradigma de
desenvolvimento móvel
Ramon Ribeiro Rabello ramon.rabello@gmail.com
É graduado em Ciência da Computação pela Universidade da Amazônia (UNAMA). Trabalha com a tecnologia Java há 4 anos e já desenvolveu projetos utilizando as linguagens Delphi, C e C++. Possui experiência nas três especificações Java: JSE, JEE e JME.Trabalhou com desenvolvimento de aplicações móveis comerciais (M-Commerce / M-Payment) e publicou artigos científicos sobre aspectos referentes à plataforma JME. Atualmente é mestrando da Universidade Federal de Pernambuco (UFPE) na área de Engenharia de Software.
O desenvolvimento de aplicações para dispositivos móveis tem evoluído exponencialmente com o tempo e já se tornou um padrão de desenvolvimento quase onipresente no sentido de que muitas empresas estão escalonando ou recrutando novos desenvolvedores para formarem seus grupos de desenvolvimento para sistemas móveis a fim de criar novas ou adaptar soluções de serviços existentes para suprir a demanda do mercado (empresas bancárias disponibilizando serviços de operações financeiras pelo celular, controle de estoque de materiais e outros).
Várias são as plataformas hoje para desenvolvimento de aplicações para dispositivos móveis. As tecnologias existentes para desenvolvimento são: Symbian, Brew, JavaME, Embedded-Linux, .NET Compact Framework e Flash Lite.
E depois de muitos rumores informando que a gigantesca Google entraria também no ramo de desenvolvimento de dispositivos móveis por meio do lançamento do tão aclamado “GPhone” (o qual seria mais um para a lista dos concorrentes do minimalista iPhone da Apple), o mesmo foi muito mais além.
Em 05 de novembro de 2007, a empresa tornou pública a primeira plataforma Open Source de desenvolvimento para dispositivos móveis baseada na plataforma Java com sistema operacional Linux, a qual foi chamada de Android. Este artigo tem como objetivo descrever a nova plataforma móvel do Google, dando uma visão geral sobre a arquitetura e componentes (uma descrição mais detalhada dos componentes será feita nos próximos artigos) da plataforma, ambiente de desenvolvimento, mostrando ao leitor passo-a-passo a construção de seu primeiro Android.
A plataforma Android foi concebida inicialmente pelo Google. A plataforma está sendo e será mantida pelo Open Handset Alliance, que é um grupo formado por mais de 30 empresas (de tecnologias de dispositivos móveis, provedoras de serviços móveis, fabricantes, etc) as quais se uniram para inovar e acelerar o desenvolvimento de aplicações, serviços, trazendo aos consumidores uma experiência mais rica em termos de recursos, menos dispendiosa em termos financeiros para o mercado móvel. Pode-se dizer que a plataforma Android é a primeira plataforma móvel completa, aberta e livre.
Esta plataforma foi desenvolvida utilizando o sistema operacional Linux. Sendo assim, todas as características intrínsecas deste sistema foram incorporadas, bem como sistema de arquivos, o kernel, os servidores de terminais (X server), etc. Estas são algumas características suportadas pela plataforma:
Framework de Applicação permitindo reuso de componentes;
Máquina Virtual Dalvik otimizada para dispositivos móveis;
Navegador Web Integrado baseado na engine open source WebKit;
Gráficos Otimizados por meio de uma biblioteca de gráficos 2D; e gráficos 3D
baseados na especificação OpenGL ES 1.0;
SQLite para armazenamento de dados em formato de estruturas relacionais;
Suporte para mídias de audio (formatos MP3, AAC, AMR), vídeo (MPEG4 e H.264) e
imagens (formatos JPG, PNG, GIF);
Telefonia GSM (dependente de hardware);
Bluetooth, EDGE, 3G, e WiFi (dependente de hardware)
Câmera, GPS, bússola, e acelerômetro (dependente de hardware)
Poderoso Ambiente de Desenvolvimento, incluindo um emulador de dispositivo,
ferramentas para depuração, analisador de memória e performance; e um plugin para a IDE Eclipse
A seguir será explicado a arquitetura e os componentes que juntos compõem a arquitetura da plataforma Android.
A arquitetura
A arquitetura da plataforma Android é dividida em várias camadas: Applications, Application Framework, Libraries e Android Runtime; e Linux Kernel.
Na camada Applications, está localizada uma lista de aplicações padrões que incluem um cliente de e-mail, programa de SMS, calendário, mapas, navegador, gerenciador de contatos, e outros que serão desenvolvidos pela comunidade, sendo todas essas aplicações escritas na linguagem Java.
Já na camada Application Framework estão os componentes que permitirão com que novas estruturas sejam utilizadas para futuras aplicações, enfatizando a reutilização de código. Os seguintes componentes fazem parte desta camada:
Um rico e extensível conjunto de componentes gráficos que pode ser utilizado para construir uma aplicação, bem como listas, grids, caixas de textos, botões, e até um navegador web embutido.
Provedores de conteúdo que habilitam às aplicações acessar dados de outras aplicações (como os Contatos, por exemplo) ou compartilhar seus próprios dados.
Gerenciador de recursos que prove acesso a recursos não-codificados como strings, gráficos, e arquivos de layout.
Um gerenciador de notificação que permite que todas as aplicações exibam mensagens de alerta personalizáveis na barra de status.
Um gerenciador de atividade que gerencia o ciclo de vida das aplicações e permite controlar os recursos previamente alocados, sendo que caso eles não estejam sendo mais utilizados, os mesmos são desalocados para liberar memória.
A camada logo abaixo é subdivida no grupo das bibliotecas (libraries) e o ambiente de execução (runtime) da plataforma Android, composto pelas bibliotecas padrão e pela máquina virtual denominada Dalvik. No primeiro grupo estão as bibliotecas escritas em C/C++, que são compostas por uma coleção de bibliotecas que são utilizadas pela plataforma Android. Estas bibliotecas são:
Biblioteca de sistema C: é uma implementação da biblioteca C padrão(libc), otimizada para dispositivos que suportam a plataforma Linux (embbeded- linux).
Bibliotecas de Mídias: as bibliotecas suportam execução e gravação da maioria dos formatos de áudio e vídeo, bem como exibição de imagens, incluindo MPEG4, H.264, MP3, AAC, AMR, JPG, e PNG.
Gerenciador de Superfície: gerencia o acesso ao display do dispositivo e camadas de gráficos 2D e 3D de múltiplas aplicações.
LibWebCore: uma moderna engine de navegador web que turbina tanto o navegador da plataforma Android e um outro navegdor qualquer desenvolvido.
SGL: uma engine de gráficos 2D.
3D libraries: uma implementação baseada na especificação OpenGL ES 1.0, a qual utiliza tanto aceleração de hardware 3D e um avançado e otimizado software para renderização de modelos tridimensionais
FreeType: renderização em formatos bitmaps e vetoriais de fontes.
SQLite: uma ponderosa e leve engine de banco de dados relacional disponível para todas as aplicações.
No que diz respeito ao ambiente de execução, a plataforma é composta pela máquina virtual Dalvik. Toda e qualquer aplicação em Android roda dentro de seu próprio processo, isto é, no contexto da sua instância de máquina virtual. Esta VM foi escrita para que os dispositivos possam suportar múltiplas máquinas virtuais eficientemente. A Dalvik executa arquivos no formato Dalvik Executable, com extensão .dex. Um arquivo .dex nada mais é do que uma espécie de bytecodes de Java (os famosos arquivos compilados .class) otimizados para a Android.
Na base, está localizado o kernel Linux, que para a Android será a versão 2.6, fornecendo serviços do núcleo do sistema como segurança, gerenciamento de memória, gerenciamento de processos, pilhas de redes, etc. A Figura 1 mostra os principais componentes da arquitetura do Android e a Tabela 1 apresenta as principais APIs.
Figura 1. As camadas da arquitetura Android
Tabela 1. Principais APIs da Android.
Activity
As peças que compõem (não necessariamente todas ao mesmo tempo) uma aplicação em Android são: Activity, IntentReceiver, Service e ContentProvider. Como este artigo só utilizará o componente Activity, o mesmo explicará somente este, sendo que os outros serão explicados em artigos futuros.
Uma Activity (ou Atividade) representa uma simples tela em branco e pode ser criada estendendo a classe Activity. As aplicações reais (por exemplo, uma lista de contatos, um organizador pessoal, um localizador geográfico, etc) serão compostas de várias Atividades. Ou seja, cada tela seria um Activity. Para passar então para uma nova tela, uma nova Activity deverá ser iniciada. A plataforma Android implementa o conceito
Pacote Descrição
android.util Contém várias classes utilitárias (classes de containers, utilitários XML)
android.os Contém serviços referentes ao sistema operacional, passagem de parâmetros e comunicação entre processos.
android.graphics Pacote principal dos recursos gráficos.
android.text android.text.method android.text.style android.text.util
Suporte para um conjunto de ferramentas de processamento de texto, suporte ao formato de texto rico (RTF), métodos de entradas, etc.
android.database Contém APIs para comunicação com o banco de dados SQLite
android.content APIs de acesso a dados no dispositivo, como as aplicações instaladas e seus recursos.
android.view O pacote principal que contém os principais componentes de interface gráfica.
android.widget Contém widgets prontos (botões, listas, gerenciadores de layout, etc) para serem utilizados nas aplicações
android.app APIs de alto-nível referents ao modelo da aplicação. É implementada por meio de Activities (Atividades)
android.provider Contém várias APIs para padrões de provedores de conteúdos (content providers)
android.telephony APIs para interagir com funcionalidades de telefonia
android.webkit Inclui várias APIs para conteúdos de context web, bem como um navegador embutido que pode ser utilizado por qualquer aplicação.
de Intent (Intenção) para indicar que a aplicação tem a intenção de realizar algo. Cada ação representa uma Intent (uma mudança de tela, por exemplo).
Uma Intent é composta principalmente de uma ação (tag <action>) e uma categoria (tag <category>) que representa uma descrição indicando o que a Intent deseja realizar. Para garantir que a Intent chamada é a desejada, a plataforma utiliza um IntentFilter (tag <intent-filter>) para filtrar a Intent de acordo com a sua ação e sua categoria. Caso a Intent não se enquadre em um dos filtros definidos, a plataforma chama a Intent que mais se aproxima para realizar a ação. As Activities, Intents e IntentFilters são definidas no arquivo chamado AndroidManifest.xml, o qual será explicado mais à frente.
Interface gráfica e layouts
Os principais componentes que fazem parte da interface gráfica com o usuário (GUI) da plataforma Android foram denominados de Views e Viewgroups.
Um View é representado pela classe android.view.View. Este componente nada mais é do que uma estrutura de dados que representa uma área retangular limitada da tela do dispositivo. Por meio dele podemos obter informações como medidas de largura e altura, desenho, mudança de foco, capacidade de rolagem (scrolling) e captura de comandos (teclas dos dispositivos) percebida por aquela área específica. A classe View é extensível e serve de base para outros widgets. A plataforma vem equipada com vários widgets já implementados prontos para o desenvolvedor utilizar em suas aplicações. Os widgets já disponíveis são: Text, EditText, InputMethod, MovementMethod, Button, RadioButton, Checkbox, and ScrollView (mais detalhes sobre estes componentes no próximo artigo).
O outro componente é representado pela classe android.view.Viewgroup. Um Viewgroup pode ser considerado um layout, isto é, um container de Views (e também de Viewgroups) que pode ser utilizado para criar estruturas mais complexas, ricas e robustas. Um Viewgroup é a classe base para outros layouts (LinearLayout, RelativeLayout, AbsoluteLayout, etc). No momento em que o método setContentView() é chamado, o mesmo recebe uma referência para o nó raiz da árvore que representa o layout a ser mostrado. Sendo assim, o mesmo informa a seus filhos para que eles possam se desenhar, validar, etc. A Figura 2 mostra a árvore que representa a hierarquia formada por Views e Viewgroups.
Figura 2. Hierarquia de Views e Viewgroups.
Preparando o ambiente de desenvolvimento
Agora vamos à prática! Mas primeiro precisamos preparar o ambiente de desenvolvimento para construir o nosso primeiro “Hello Android”. Para isso, será necessário seguir alguns passos: instalar o SDK, instalar (caso ainda não tenha instalado) uma IDE para desenvolvimento (para este artigo foi utilizada a IDE Eclipse Europa) caso
ainda não esteja instalada, instalar o plugin ADT para Eclipse e configurar o plugin para este “enchergar” o SDK.
O primeiro passo é instalar o SDK do Android que está disponível no site http://code.google.com/android/download.html. No site estão disponíveis versões para as plataformas Windows, Mac OS X e Linux. Na época da escrita deste artigo, foi utilizada a versão m3_rc37a do SDK para Windows, pode ser que já exista uma versão mais atualizada disponível para download.
Depois, o mesmo deverá ser descompactado em algum local em sua máquina. Por padrão, os SDKs são descompactados nos diretórios nomeados android_sdk_<plataforma>_<release>_<build>. Nesta pasta estão inclusas as sub-pastas tools/, samples/ e outras.
Se preferirem, podem adicionar a pasta tools/ na variável de ambiente PATH no Windows para que não seja necessário fornecer o diretório todo dos binários da plataforma para rodá-los a partir da linha de comando.
O próximo passo é instalar o ADT (Android Development Tools), que é um plugin para Eclipse que inclui uma variedade de ferramentas que auxiliam o desenvolvedor em todas as fases de desenvolvimento (criação, execução, depuração e distribuição). Para instalá-lo, devemos seguir os passos:
1. Dentro do Eclipse, aponte para Help -> Software Updates -> Find and Install.... 2. Na janela que aparecer, selecione Search for new features to install e clique em Next. 3. Clique no Botão New Remote Site.
4. Na caixa de diálgo, digite uma descrição no campo Name (por exemplo, Android) e digite o seguinte no campo URL: https://dl-ssl.google.com/android/eclipse/ (Figura
3). Pressione OK.
5. Vá prosseguindo a instalação clicando em Next.
6. Na última tela você perceberá que o ADT não é assinado. Mesmo assim, você pode aceitar a instalação clicando em Install All.
7. Reinicie o Eclipse.
Pronto, o ADT já está instalado. Agora só falta configurá-lo para que o mesmo possa “enchergar” o SDK. Para isso, siga os passos:
1. No Eclipse, vá em Window -> Preferences... 2. Selecione Android no painel esquerdo.
3. Em “SDK Location”, pressione Browse... para localizar o diretório do SDK. 4. Clique em Apply, e depois em OK.
A Figura 4 mostra como deve estar a configuração do ADT.
Figura 4. Configurando o ADT.
Agora sim! Estamos prontos para começar a criar nosso primeiro “Hello Android”.
Criando seu primeiro Android
Para criarmos o nosso primeiro “Hello Android”, precisaremos criar um Android Project (Figura 5). Para isso temos que:
1. Apontar para File -> New -> Project
2. Selecionar Android -> Android Project, e clicar em Next
3. Como será o nosso primeiro aplicativo em Android, selecione Create new project in workspace para começar um projeto desde o início (caso queira usar os exemplos que já vêm no SDK, selecione Create project from existing source e selecione uma aplicação dentro da pasta samples/. Caso exista um arquivo de manifesto do Android (arquivo AndroidManifest.xml), as configurações deste serão utilizadas). No campo Project Name digite “HelloAndroid”. Em Package name digite android.webmobile.exemplo, o qual será o pacote da aplicação. Em Activity digite HelloActivity. Este campo representa uma Activity e será explicado na próxima seção. Em Application name, que será o nome da aplicação, digite “AndroidApplication”.
Após esses passos, os campos devem estar preenchidos como mostra a Figura 6.
Figura 5. Criando um projeto Android.
Figura 6. Configurando o projeto.
Para rodar a aplicação, basta executar o aplicativo como uma Aplicação Android, clicando com o botão do lado direito em cima do projeto e indo em Run As -> Android Application. Nesse momento o emulador iniciará e carregará a aplicação. Se tudo estiver correto, o emulador deve mostrar a sua aplicação de acordo com a Figura 7. No emulador,
se você clicar no botão Home (representado por uma casa), poderá navegar pelo menu do emulador (Figura 8) e verá as seguintes opções (da esquerda para a direita):
Applications: aqui ficarão as aplicações que você for instalar;
Contacts: os contatos de sua agenda poderão ser gerenciados nessa opção; Browser: simula um navegador embutido;
Maps: uma espécie de Google Maps para o Android;
Dev Tools: configurações avançadas para desenvolvimento (debug, mostrar status de conexão, etc).
Caso você queira ver alguns exemplos de aplicações em Android, na pasta Applications, clique em API Demos que será carregada uma aplicação mostrando a maioria das funcionalidades disponibilizadas pela plataforma.
Figura 8. Menu do emulador.
Após a criação do projeto, o plugin criará a estrutura de diretórios (Figura 9) necessária para um projeto Android. A pasta src/ dentro do pacote criado contém uma classe que representa uma Activity (Listagem 1), no nosso exemplo esta classe tem o nome de AndroidActivity, e uma classe utilitária R.java (Listagem 2) que é gerada automaticamente (é recomendado não alterar esta classe manualmente) pela plataforma. Ela é utilizada para facilitar a obtenção dos componentes ou recursos apenas informando o seu nome.
Você pode perceber que na raiz do projeto foi criado um arquivo chamado AndroidManifest.xml. Esse arquivo é obrigatório e é nele que serão feitas as configurações de todos os recursos utilizados pela aplicação (Activities, componentes gráficos, layouts, imagens, etc). A Listagem 3 mostra o conteúdo desse arquivo.
A pasta res/ contém os recursos que serão utilizados pela aplicação. Estes recursos são organizados em pastas de acordo com o seu propósito. O diretório res/ possui três subpastas:
drawable: esta pasta (contendo somente a imagem icon.png) deve conter todos os
recursos de imagens (PNG e JPG) utilizados na aplicação. layout: contém as definições dos layouts utilizados na aplicação que nada mais são do
que arquivos no formato XML. No exemplo é representado pelo arquivo main.xml. O conteúdo deste arquivo é mostrado na Listagem 4.
values: contém valores estáticos (strings, por exemplo) que podem ser carregados de um arquivo XML. No nosso projeto é representado pelo arquivo strings.xml, mostrado na Listagem 5.
Para maiores informações sobre os tipos de recursos disponíveis na plataforma Android, visite o site http://code.google.com/android/reference/available-resources.html.
Figura 9. Estrutura de diretórios de um projeto Android.
Listagem 1. HelloActivity.java
package com.android.exemplo;
import android.app.Activity; import android.os.Bundle;
public class HelloAndroid extends Activity {
@Override
public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); } } Listagem 2. R.java package com.android.exemplo;
public final class R {
public static final class attr { }
public static final class drawable {
public static final int icon=0x7f020000; }
public static final class layout {
public static final int main=0x7f030000; }
public static final class string {
public static final int app_name=0x7f040000; } } Listagem 3. AndroidManifest.xml <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.android.exemplo"> <application android:icon="@drawable/icon">
<activity class=".HelloAndroid" android:label="@string/app_name"> <intent-filter>
<action android:value="android.intent.action.MAIN" />
</intent-filter> </activity> </application> </manifest> Listagem 4. main.xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"> <TextView android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="Hello World, HelloAndroid" /> </LinearLayout> Listagem 5. strings.xml <?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">AndroidApp</string> </resources>
Analisando os arquivos gerados
Na Listagem 1, percebemos que a classe HelloActivity.java contém um único método chamado onCreate(). Este método deve ser sobrescrito para que uma Activity seja criada. Perceba que este método possui a anotação @Override informando que este método está sendo sobrescrito. Uma das inúmeras novidades da plataforma é a utilização do Tiger (codinome do Java 5), permitindo que os recursos dessa versão (Annotations, Generics, Autobox, etc) sejam utilizados a fim de construir aplicações com nível maior de complexidade, tarefa um tanto quanto desafiante no mundo móvel.
O outro método, setContentView(), como foi explicado anteriormente, é utilizado para a visualização dos componentes de interface gráfica com o usuário (GUI). A variável R.layout.main faz referência ao layout definido no arquivo main.xml mostrado na
Listagem 3. Além dos layouts e widgets definidos no arquivo XML, a plataforma permite
que ambos sejam criados via código.
Na Listagem 2, percebemos que a classe R.java contém um conglomerado de classes estáticas finais representando os recursos utilizados na aplicação que podem ser acessados pela seguinte sintaxe: R.{recurso}.{variavel}. Por exemplo, para utilizar o layout definido no arquivo main.xml devemos usar a sintaxe R.layout.main.
A Listagem 3 mostra o arquivo AndroidManifest.xml, talvez o sistema nervoso de uma aplicação em Android. É nele que ficam as definições referentes à aplicação, às Activities, aos IntentFilters, etc. A tag <application> contém o atributo android:icon, o qual possui o valor @drawable/icon, que representa o ícone da aplicação. O acesso a recursos no Android é feito por meio da URI: @{recurso}/{id}, onde {recurso} representa o recurso que queremos utilizar e {id} o nome da variável que faz referência a esse recurso na classe R.java. Por exemplo, a URI @drawable/icon refere-se ao ícone icon.png que se encontra na pasta drawable e é referida na classe R.java pela classe drawable e variável icon. A tag <activity> define uma Activity. Aninhada a ela está a tag <intent-filter>, que representa os filtros para as Intents. Seguindo na hierarquia do arquivo XML, vemos a tag <action> representando a ação a ser executada pela Intent. Esta tag possui o atributo android:value que possui o valor “android.intent.action.MAIN”, indicando que essa é a ação principal. A tag <category> representa a categoria a qual a Intent pertence. No exemplo, o valor do atributo android:value é “android.intent.category.LAUNCHER” descrevendo que esta Intent será utilizada para iniciar a execução da Activity.
Na Listagem 4, o arquivo main.xml define o layout utilizado. Ele inicia com a tag <LinearLayout> informando que a aplicação está utilizando o layout LinearLayout, que dispõe os componentes linearmente em uma única orientação. A tag possui vários atributos, dentre eles os principais são:
android:orientation: indica a orientação em que os componentes devem ser dispostos. Ela pode ser o valor “horizontal” ou “vertical”.
android:layout_width: representa como a largura do layout se comportará a medida em que os componentes são dispostos. O valor “fill_parent” informa que o conteúdo do layout deve ser disposto de forma a preencher toda a sua área de acordo com o espaço que ocupa seus filhos.
android:layout_height: o mesmo que o atributo android:layout_width só que para a altura.
Dentro da tag <LinearLayout>, temos definido um componente TextView por meio da tag <TextView>. Esse componente representa um texto estático. No nosso exemplo, ele que é responsável por mostrar o texto “Hello World, Hello Android”. Fazendo uma comparação, o JLabel está para o Swing assim como o TextView está para o Android. A tag <TextView> possui os mesmos atributos de <LinearLayout> (lembram que um Viewgroup é também um View?), a única diferença é que o valor do atributo android:layout_height é “wrap_content”, que indica que a altura do componente se adequará de acordo com seu conteúdo. O atributo android:text é o responsável pelo texto do componente. Uma funcionalidade interessante no ADT é que, caso você mude qualquer recurso em sua aplicação (cria um novo arquivo de layout, adiciona imagens, etc) o mesmo irá sincronizar essas mudanças automaticamente, facilitando mais a vida do desenvolvedor.
O arquivo strings.xml, na Listagem 5, inicia com a tag <resources> para indicar que dentro dela serão adicionados recursos, que no nosso exemplo, será somente a tag <string> que representa a descrição da aplicação. O atributo name recebe o valor “app_name” que é referenciado no arquivo AndroidManifest.xml na tag <activity>, no atributo android:label pela URI @string/app_name.
Distribuindo a aplicação
Depois de encaixar e soldar as peças, realizar vários testes, chegou a hora de distribuir a aplicação. Para fazer o deploy basta que seja copiado o arquivo .apk (acrônimo para Application Package), que é uma espécie de .jar executável que é utilizado pelo gerenciador de aplicativos do Android para instalar e carregar a aplicação. Por meio do plugin ADT é possível exportar esta arquivo clicando com o botão direito em cima do projeto, indo em Android Tools -> Export Application Package... (Figura 10).
Este arquivo (no nosso exemplo o arquivo gerado será HelloAndroid.apk) já é copiado automaticamente pelo ADT no momento em que o aplicativo inicia sua execução, facilitando ao desenvolvedor esta tarefa de deploy.
Figura 10. Distribuindo uma aplicação.
Conclusão
A plataforma Android com certeza é uma das apostas mais audaciosas do Google, o que de fato inseriu a gigantesca no ramo de desenvolvimento para dispositivos móveis. Também revolucionou ao anunciar a plataforma como sendo a primeira de caráter Open Source, por meio da OHA – Open Handset Alliance (para saber mais detalhes sobre este desafio visite o site http://code.google.com/android/adc.html).
Um exemplo disso é o Android Developer Challenge (ADC), uma espécie de desafio em que os 50 melhores aplicativos desenvolvidos na plataforma Android serão premiados, somando um total de 10 milhões de dólares! Acreditam com isso incentivar o desenvolvimento por meio de uma amostragem do nível de aceitação da plataforma móvel no mundo todo. O site do desafio possui um formulário para submissão do aplicativo. Para maiores informações sobre o desafio visite http://code.google.com/android/adc.html.
Apesar da gama enorme de recursos e de funcionalidades que a plataforma suporta, ela ainda está um pouco “beta” e algumas funcionalidades ainda faltam ser implementadas (conexão via bluetooh, por exemplo), mas deverão estar disponibilizado nos próximos releases do SDK.
Acredita-se que os primeiros dispositivos que suportarão a plataforma serão lançados ainda no primeiro semestre de 2008. E para nós desenvolvedores basta esperarmos o que o OHA promete.
Este é o término da primeira parte deste artigo. O objetivo dele foi dar uma visão geral sobre a nova plataforma móvel Android desenvolvida pelo Google. O próximo artigo discutirá mais sobre componentes de interface gráfica com o usuário. Até breve!
Links
Site Oficial do Android
code.google.com/android/
The Open Handset Alliance
http://www.openhandsetalliance.com/
Site do Android Developer Challenge
