Introdução ao Android

Guia do artigo: Android Tutorial

• O surgimento do Android e o impacto no mercado
• Instalando e conhecendo o Android SDK
• Criando seu primeiro projeto Android
• Definindo o layout da tela no arquivo XML
• Escrevendo o código Java na Activity
• Conclusão

O desenvolvedor Java pode hoje aproveitar seu conhecimento na linguagem para criar aplicativos dentro de uma nova e empolgante área: o mercado dos smartphones e tablets. O sistema operacional Android, que é líder de mercado neste segmento, utiliza Java como a linguagem de programação para seus aplicativos, e traz um conjunto rico de classes e ferramentas para o desenvolvimento de programas que façam uso dos principais recursos existentes nestes aparelhos.

Saiba mais: Série Primeiros passos no Android

Não podemos contestar o que é um fato: o sistema operacional Android é hoje líder absoluto nos tablets e smartphones disponíveis no mercado mundial. Lançado pelo Google com o intuito claro de disputar com o iPhone da Apple, a plataforma móvel do “robozinho” ganhou uma enorme fatia do mercado por várias (e merecidas) razões:

• Possui uma interface agradável e fácil de usar, que conquista tanto usuários novatos como os mais experientes;
• Sua arquitetura aberta possibilita que o mesmo seja utilizado em aparelhos de vários fabricantes;
• Utiliza a linguagem Java para criação de seus aplicativos.

Só esse último item já faz “brilhar” os olhos da maioria dos desenvolvedores – afinal de contas, que não conhece Java hoje em dia?

Assim, o programador com o mínimo de conhecimento em Java já poderá se “aventurar” pelo mundo do desenvolvimento móvel e, graças a um conjunto de ferramentas de desenvolvimento e uma documentação completíssima disponibilizada pelo Google, terá uma “curva de aprendizagem” bem menos acentuada do que em outras plataformas no mercado (o desenvolvimento para iOS, por exemplo, exige o conhecimento de Objective-C, uma linguagem ainda distante de muitos desenvolvedores).

A cada dia que passa, dispositivos equipados com Android tornam-se cada vez mais populares e se confirmam como líderes no mercado de smartphones e tablets. Neste artigo, vamos conhecer um pouco mais sobre essa nova e revolucionária plataforma móvel, sua breve história e como ela pode ser um novo e excitante mundo a ser explorado pelo programador Java.

O surgimento do Android e o impacto no mercado

O sistema operacional Android foi criado pela Android, Inc., empresa estabelecida em 2003 na Califórnia (dentro do célebre Vale do Silício), com o intuito de desenvolver soluções de software para plataformas móveis.

Visando uma maior participação no mercado de dispositivos móveis, o Google começou a financiar as pesquisas da Android, Inc., chegando finalmente a adquirir a empresa em 2005. No período em que se seguiu, diversos rumores começaram a surgir sobre as razões por trás do crescente interesse do Google em sistemas móveis.

Em 2007, os rumores provaram ser verdadeiros. Junto de outras empresas, o Google formou a Open Handset Alliance, um grupo voltado para pesquisa e desenvolvimento no campo de dispositivos móveis, e anunciou oficialmente o Android, ainda em versão beta. A versão 1.0 oficial foi lançada em outubro de 2008, sendo o HTC Dream o primeiro smartphone com o sistema a chegar às lojas.

Saiba mais: Artigos da Série Kotlin

Concorrendo obviamente com o iPhone, o aparecimento do robozinho verde gerou até uma “ruptura” entre as (até então) aliadas Google e Apple: Eric Schmidt, na época CEO do Google e membro do conselho de diretores da Apple, renunciou a este último cargo, em razão do fato de (dizem) Steve Jobs não ter gostado nada da “nova praia” em que o Google estava pisando (tal fato, segundo rumores, levaram também a Apple a criar seu próprio sistema de mapas para substituir o serviço do Google posteriormente).

O Android é baseado no kernel (núcleo) do sistema operacional Linux. Dessa forma, tornou-se (para desespero de muitos fãs “radicais” do Linux) a versão (ou “distribuição” – apesar de muitos não concordarem que o Android seja uma distribuição Linux “de facto”) mais usada no mundo do sistema operacional idealizado por Linus Torvalds.

O que não se pode negar é o fato do Android herdar, com isso, toda a estabilidade, eficiência e segurança, velhas conhecidas do Linux. Outra característica importante advinda do fato do uso de um sistema open source como base é que o Android também tem seu código-fonte disponibilizado pelo Google (o código-fonte de uma nova versão é liberado em um curto período após o seu lançamento oficial, e pode ser obtido em aqui.

Apesar de ser liderado pelo Google, o processo de desenvolvimento do Android conta com a participação direta das empresas participantes da Open Handset Alliance (como Samsung, Sony, HTC, Motorola e LG), e as decisões relativas ao sistema, assim como os recursos das novas versões, são todas realizadas em comum acordo pelo grupo.

Atualmente, o sistema encontra-se na versão 4.2 (Figura 1), de codinome “Jelly Bean”. Essa nomenclatura, aliás, é outro fato curioso sobre o Android. Desde a versão 1.5 (“Cupcake”), são dados nomes de doces e sobremesas para cada nova versão. Os nomes são escolhidos seguindo a ordem alfabética. Nessa “lógica”, a próxima versão provavelmente começará com a letra K.

A maciça adoção do Android por diversos fabricantes (e consequentemente milhões de usuários) fez com que o sistema chegasse, em novembro de 2012, a deter 75% do mercado de sistemas operacionais para smartphones, de acordo com uma pesquisa do IDC (International Data Corporation – veja a seção Links no final do artigo).

Outro fato que contribui (e muito) para o vertiginoso crescimento do Android e da quantidade de aplicativos disponíveis para ele (mais de 700.000, em dezembro de 2012 – vide Links) é o uso do Java como linguagem para desenvolvimento de suas aplicações nativas.

A execução dos aplicativos Java no Android é feita por uma máquina virtual Java denominada Dalvik – outro projeto open-source, criado por Dan Bornstein. A Dalvik possui uma implementação própria das principais APIs do Java, baseada no código das bibliotecas do projeto Apache Harmony, contendo os principais pacotes e classes da linguagem Java, velhos conhecidos dos desenvolvedores. Para uma lista completa dos pacotes disponíveis, consulte o link da API do Android disponível no final do artigo.

Outro detalhe importante: o Android não implementa o Java SE, o Java EE e nem o Java ME (veja o BOX 1). Ele possui, sim, um grande subconjunto de pacotes e classes padrões do Java, mas voltadas apenas ao desenvolvimento de aplicativos para o Android. Tal fato levou a uma batalha jurídica entre Oracle e Google, pouco tempo atrás, sobre uma possível violação de copyright – o que já foi devidamente resolvido entre as empresas.

Junto das classes básicas do Java, o Android SDK (Software Development Kit) traz também as APIs específicas do Android (dentro dos pacotes android.*), com classes para criação de interfaces, multimídia, uso de sensores, GPS, e outros recursos existentes nos aparelhos.

Para conhecer bem a plataforma, nada melhor que fazer o download do Android SDK e familiarizar-se com seus componentes principais.

Instalando e conhecendo o Android SDK

Para criar aplicativos para Android você deverá ter, obviamente, o JDK instalado. Por motivos de segurança, procure utilizar sempre a versão mais recente – no momento da elaboração deste artigo, a 7u21.

Até pouco tempo, o processo de preparação para criação de aplicativos Android consistia em etapas inicialmente desconexas: baixar e instalar o Eclipse; baixar e configurar o plugin do Android para o mesmo; e obter as imagens da versão de desenvolvimento desejada.

Hoje, um pacote com todos esses elementos pronto é disponibilizado no site oficial da Android Developers. Este pacote está disponível para sistemas operacionais Windows, Mac OS X e Linux. Para obtê-lo, você deve entrar no site oficial do desenvolvedor Android e clicar no link indicado na Figura 2 para baixar o pacote que contém o SDK e a ferramenta de desenvolvimento (uma versão “customizada” do Eclipse).

Ao clicar no link Get the SDK (Figura 2), você será levado à página de download principal, onde se encontram algumas informações sobre o download e o link adequado para o seu sistema operacional (Figura 3).

O ADT (Android Developer Tools) Bundle contém:

• Uma versão customizada do ambiente de desenvolvimento integrado Eclipse, com o plugin do Android já instalado. Este plugin, entre outros recursos, facilita a execução e depuração de um aplicativo tanto no emulador quanto em um aparelho real, e possui também um editor de interface visual;
• Um conjunto de ferramentas para o SDK e para a plataforma Android, que também está integrado ao Eclipse;
• O emulador do Android;
• A “imagem” da versão mais recente do sistema operacional, para uso no emulador (no momento da elaboração deste artigo a versão mais atual era a 4.2.2).

Após terminar o download, descompacte o pacote em algum local do seu computador – pode ser, por exemplo, dentro de uma pasta denominada Developer, nos seus Documentos.

Existem duas pastas principais dentro do pacote: eclipse, que contém a versão do Eclipse mencionada; e sdk, onde estão os arquivos do kit de desenvolvimento (bibliotecas, utilitários e documentação, entre outros).

Agora podemos começar o nosso projeto! Para iniciar o Eclipse, basta clicar duas vezes sobre seu ícone, existente dentro da pasta eclipse.

Criando seu primeiro projeto Android

Ao abrir o Eclipse versão ADT pela primeira vez e definir a pasta onde serão colocados seus projetos (o seu Workspace), será mostrada a tela de boas-vindas, exibida na Figura 4.

Feche a tela de introdução clicando sobre o X indicado na Figura 4. Você então terá acesso à tela principal do ambiente de desenvolvimento. “Veteranos” do Eclipse não encontrarão dificuldades em usar esta versão. Trata-se do mesmo Eclipse de sempre, apenas acrescido das funções que facilitam o desenvolvimento para Android.

Como prática, vamos criar um pequeno aplicativo que pode ajudar pessoas que gostam de “tentar a sorte” na MegaSena. Utilizando a classe Random do Java, faremos o sorteio de seis números distintos, entre 1 e 60, como sugestão de aposta.

Antes de iniciar a criação do projeto, no entanto, precisamos ter um Android Virtual Device (AVD), dispositivo virtual do Android, configurado para uso. Trata-se de uma “instância” de uma versão do Android para ser executada dentro do emulador. Podemos criar o AVD rapidamente, sem nem mesmo sair do Eclipse. Para isso, clique sobre o botão indicado na Figura 5, que abre o AVD Manager.

Será aberta uma tela com a lista de AVDs configurados (nenhum, até o momento). Para criar o novo AVD, clique sobre o botão New.... Feito isso, preencha os campos da tela que será exibida, como demonstra a Figura 6.

Em AVD Name, definimos um nome para o dispositivo virtual. Em Device, escolha um aparelho ou tamanho de tela e resolução compatível com a dos dispositivos onde pretende executar o aplicativo. Em seguida, selecione a versão disponível do Android em Target (no exemplo, é a versão 4.2.2 – dependendo de quando você realizar o download do pacote poderá ser outra).

Certifique-se em deixar marcadas as opções Hardware keyboard present (assim você poderá digitar diretamente pelo teclado do computador para testar o programa, sem ter que usar o teclado virtual do Android) e Snapshot (com esta opção ativada, o emulador irá “congelar” no estado em que for fechado – assim não haverá necessidade de uma nova inicialização do Android sempre que o emulador for executado). Em seguida clique em OK e feche a tela da listagem de AVDs.

Agora podemos passar à criação do aplicativo. Para criar o novo projeto, clique sobre o botão da barra de ferramentas indicado na Figura 7.

Será mostrada a tela da Figura 8, onde poderemos especificar o nome do projeto, seu pacote padrão para as classes e a versão mínima do SDK necessária para executar o aplicativo. Você pode manter os valores mostrados para as versões do SDK. Com elas, seu aplicativo será compilado com a versão mais atual (4.2), mas também manterá compatibilidade com qualquer versão igual ou superior à 2.2 (muitos aparelhos no mercado ainda executam nas versões 2.x do Android).

Informe o nome desejado para o projeto em Application Name. Neste exemplo, usamos “MegaSena”. Em Package name, informe um nome para o pacote principal das classes, por exemplo, net.querino.android.megasena.

A configuração Minimum Required SDK é importante porque ela define a versão mínima do Android requerida pelo aplicativo que está sendo criado. Colocar uma versão mais antiga indica que seu aplicativo poderá executar em uma variedade maior de aparelhos (na Figura 8, indicamos a versão 2.2 como a mínima – isso faz com que nosso aplicativo rode em qualquer versão do Android igual ou superior a esta), mas também limitará os recursos disponíveis no projeto (para manter a compatibilidade com versões mais antigas, não poderemos usar recursos existentes somente nas versões mais novas).

Em seguida, clique em Next. As telas posteriores trazem configurações que não modificaremos no nosso projeto, portanto, clique duas vezes em Next até chegar a Finish. Concluído este processo será criada a estrutura básica de um projeto Android, como você pode observar na Figura 9.

À esquerda, no Package Explorer do Eclipse, podemos ver a estrutura de pastas e arquivos do nosso projeto. O código-fonte Java fica dentro da pasta src, indicada em (1). Repare que possuímos uma única classe, denominada MainActivity, e que ela está dentro do pacote que definimos na criação do projeto. O item marcado em (2) indica que nosso projeto será compilado com a versão 4.2.2 do Android (mas mantendo compatibilidade com a versão 2.2).

A pasta res é onde ficam os recursos usados no projeto, como arquivos XML e imagens. No momento, o arquivo que nos interessa fica na subpasta layout, indicada em (3): é o arquivo activity_main.xml, que contém a especificação da tela principal do nosso programa. A visualização gráfica deste arquivo é exibida em (5).

Por fim, outro elemento importante em um projeto Android é o arquivo AndroidManifest.xml, indicado em (4). Nele, configuramos diversos aspectos do projeto, como os recursos do aparelho que serão utilizados, versão, etc. Não precisaremos modificá-lo para este exemplo.

Uma aplicação Android básica consiste em arquivos XML que especificam o layout de uma tela (ou seja, quais elementos ela possui, onde ficarão localizados e quais suas configurações) e subclasses da classe android.app.Activity, que atuam como controladora da tela. O modelo de projeto inicial vem com uma tela contendo a mensagem “Hello, World” e um exemplo básico de Activity (veja o BOX 2) controladora desta, a MainActivity, localizada na pasta src.

BOX 2. O Que é uma Activity?

Uma Activity é uma classe do Android SDK, existente no pacote android.app, que contém os métodos e eventos referentes ao ciclo de vida de uma tela em um projeto. Criamos subclasses desta para podermos especificar os eventos e métodos de controle de uma tela e dos objetos que a compõem. Porém, a definição de quais são estes objetos, bem como seus eventos, devem ficar no arquivo XML equivalente.

Definindo o layout da tela no arquivo XML

O primeiro passo na criação do aplicativo consistirá na elaboração da sua interface. Ela será bastante simples: conterá um objeto Button que, ao ser clicado, realizará o sorteio dos seis números. Estes então serão mostrados ao usuário em um GridView, que exibe uma série de dados em uma grade.

Como você pode observar, podemos montar visualmente o layout da tela arrastando e configurando os objetos pelo editor do Eclipse. Porém, desenvolvedores mais experientes (e a documentação oficial do Google) preferem usar a edição direta do arquivo em XML. Com a ajuda do autocompletar do Eclipse, escrever o XML fica realmente bastante intuitivo.

Deste modo, alterne para a visualização em XML do arquivo de layout clicando sobre a aba activity_main.xml, na parte inferior do editor da tela (ela fica logo à direita da aba Graphical Layout). O arquivo XML padrão para o layout da tela principal traz um único elemento do tipo TextView, contendo a mensagem “Hello world!”. Remova o TextView, excluindo as linhas correspondentes, e acrescente o GridView e o Button, seguindo a Listagem 1.

<RelativeLayout 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:paddingBottom="@dimen/activity_vertical_margin"
      android:paddingLeft="@dimen/activity_horizontal_margin"
      android:paddingRight="@dimen/activity_horizontal_margin"
      android:paddingTop="@dimen/activity_vertical_margin"
      tools:context=".MainActivity" >
   
      <GridView
          android:id="@+id/gridView1"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_alignLeft="@+id/button1"
          android:layout_alignRight="@+id/button1"
          android:layout_below="@+id/button1"
          android:layout_marginTop="10dp"
          android:numColumns="3"
          android:stretchMode="columnWidth" >
      </GridView>
   
      <Button
          android:id="@+id/button1"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:layout_alignParentTop="true"
          android:layout_centerHorizontal="true"
          android:layout_marginTop="20dp"
          android:onClick="onClick"
          android:text="Sortear Novos Números" >
     </Button>
   
  </RelativeLayout> 

Os dois elementos (Button e TextView) estão contidos dentro da tag <RelativeLayout>, a qual indica o gerenciador de layout que está sendo usado.

Os gerenciadores de layout estabelecem como os objetos são organizados na tela. Especificamente, o gerenciador de layout relativo (RelativeLayout) determina que os elementos fiquem posicionados em relação a outros elementos ou à margem da tela.

A configuração numColumns do GridView indica que este possuirá três colunas em cada uma de suas linhas. Como colocaremos nele seis números, teremos então duas linhas com dados. Repare que o GridView possui o id (identificador) gridView1, e que sua posição (opções layout_*) está especificada em relação ao button1.

O Buttton (que possui o id button1), por sua vez, está posicionado em relação às margens da tela. Note que sua propriedade text indica “Sortear Novos Números”. Este valor será exibido dentro do mesmo, como rótulo. A propriedade onClick define o nome de um método (que criaremos daqui a pouco na Activity) e que será disparado quando o botão for “clicado” (ou tocado, se você preferir).

Para definir a forma como os números serão exibidos dentro de cada célula do GridView, vamos criar um novo arquivo de layout. Poderíamos usar um dos layouts padronizados existentes no Android, mas como queremos formatar de modo customizado o conteúdo de cada célula (com seu conteúdo centralizado e em negrito), precisamos criar um arquivo.

Para criar um novo arquivo de layout, clique sobre o botão New Android XML File existente na barra de ferramentas do Eclipse indicado na Figura 10.

Feito isso, será exibida a janela da Figura 11, onde você deverá configurar o novo arquivo XML a ser criado. Para indicar que se trata de um arquivo XML para layout de tela, em Resource Type, escolha Layout. Especifique elemento.xml como o nome do arquivo (em File) e clique então em Finish. Por fim, altere o conteúdo do arquivo para que ele fique como a Listagem 2.

<?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:layout_width="match_parent"
      android:layout_height="match_parent"
      android:orientation="vertical" >
   
      <TextView
          android:id="@+id/numero"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:layout_gravity="center"
          android:text=""
          android:textAppearance="?android:attr/textAppearanceLarge"
          android:text />
   
  </LinearLayout> 

O layout do conteúdo de cada célula do GridView também precisa ser organizado por um gerenciador de layout. Neste caso, é usado o layout linear (LinearLayout). Ele organiza os elementos de forma muito simples: horizontalmente, um ao lado do outro, ou verticalmente, um abaixo do outro. Como nosso layout de célula vai conter apenas uma informação de texto (um único TextView), essa configuração não fará diferença (mas repare que estamos especificando a mesma como vertical, na opção orientation).

O componente TextView, que possui o identificador (id) numero, é onde exibiremos o número sorteado. Suas configurações indicam que ele ficará centralizado em cada célula (layout_gravity=”center”) e em negrito (“textStyle=”bold”).

Com o layout pronto, podemos passar para a escrita do código Java!

Escrevendo o código Java na Activity

Após a finalização da interface, devemos escrever o código Java que fará o programa realmente “funcionar”. Ele deverá ser adicionado à subclasse de Activity (veja o BOX 2) – denominada MainActivity – criada automaticamente com o novo projeto.

Deste modo, abra o arquivo MainActivity.java, e edite seu código de forma que fique como na Listagem 3.

package net.querino.android.megasena;
   
  import java.util.Arrays;
  import java.util.Random;
   
  import android.app.Activity;
  import android.os.Bundle;
  import android.view.View;
  import android.widget.ArrayAdapter;
  import android.widget.GridView;
  import android.widget.Toast;
   
  public class MainActivity extends Activity {
   
   private Random random;
   private GridView grid;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    random = new Random();
    grid = (GridView)findViewById(R.id.gridView1);
    atualizarNumeros();
   }
   
   private void atualizarNumeros() {
    Integer[] numeros = new Integer[6];
    for (int i = 0; i < 6; i++) {
     numeros[i] = random.nextInt(60) + 1;
     for (int j = 0; j < i; j++) {
      if (numeros[i] == numeros[j]) {
       i--;
       break;
      }
     }
    }
    Arrays.sort(numeros);
    ArrayAdapter<Integer> adaptador = new ArrayAdapter<Integer>(this, 
      R.layout.elemento, R.id.numero, numeros);
    grid.setAdapter(adaptador);           
   }
   
   public void onClick(View v) {
    atualizarNumeros();
    Toast.makeText(this, "Boa sorte! :)", Toast.LENGTH_SHORT).show();
   }
   
  } 

No início da classe, declaramos um objeto da classe Random (sim, o bom e velho java.util.Random do Java). Ele será usado para sortear os números. Declaramos também um objeto GridView, para que possamos ter uma referência à grade existente na tela.

O ciclo de vida básico de uma tela (representada pela sua Activity) envolve etapas como sua criação, ativação, pausa, reativação e finalização. O evento onCreate() é aquele que é executado no momento da sua criação, e devemos sobrescrevê-lo para inserir o código de inicialização da tela.

O método setContentView() existente em onCreate() faz a “conexão” entre a Activity e o seu respectivo arquivo de layout (representado por R.layout.activity_main). Em seguida, instanciamos a classe Random para geração dos números aleatórios e, por meio do método findViewById(), fazemos com que a variável local grid “aponte” para o GridView definido no layout.

Note o uso da classe R, tanto no acesso ao arquivo de layout quanto ao objeto existente dentro dele (R.id.gridView1). Trata-se de uma classe gerada automaticamente pelo plugin do Android para o Eclipse, e que serve para referenciarmos recursos existentes em arquivos XML. Ao final do método onCreate(), chamamos o método privado atualizarNumeros(), para gerar um conjunto inicial de números, e que será exibido assim que o aplicativo aparecer.

Em atualizarNumeros(), declaramos um vetor de seis elementos Integer, que armazenará os números sorteados. Dentro do laço, realizamos a geração dos seis valores, por meio da chamada a nextInt(), existente em Random. Repare que, ao sortear, percorremos os elementos já gerados anteriormente para checar se houve repetição. Caso o valor já tenha sido sorteado antes, repetimos o sorteio. Ao final, ordenamos os valores chamando o método sort() da classe Arrays do Java.

Para que os valores sejam exibidos no GridView, usamos uma classe especial do Android denominada ArrayAdapter. Esta classe faz a conexão entre um Array (que pode ser um vetor tradicional ou uma List) e um objeto visual (que pode ser um GridView, ListView ou Spinner). Assim, depois de fazer a ordenação do vetor de números, criamos uma instância de ArrayAdapter denominada adaptador, passando ao seu construtor quatro parâmetros necessários: uma referência ao “contexto” atual – this; o layout para a exibição dos dados no GridView – R.layout.elemento; o nome do objeto contido dentro deste layout onde os valores existentes no vetor ou List serão exibidos – R.id.numero é o TextView definido na Listagem 2; e, finalmente, o vetor com os valores – numeros.

O GridView usa um objeto ArrayAdapter configurado como sua fonte de dados. Para realizar esta configuração em grid, executamos o seu método setAdapter(), passando adaptador como parâmetro.

Quando o usuário quiser obter novos números, bastará clicar sobre o botão, o que ocasionará a execução do método onClick(). Dentro dele, geramos novamente os números (atualizando também o adaptador) ao chamar atualizarNumeros() e exibimos uma mensagem rápida (usando um Toast, uma pequena janela de mensagem do Android).

O aspecto final da execução do aplicativo será semelhante ao da Figura 12.

Conclusão

O Android é hoje líder do mercado de sistemas operacionais para dispositivos móveis por motivos claros: além de possuir uma interface agradável e intuitiva, tem o sistema operacional Linux como sua base, garantia de estabilidade e segurança, e é mantido como uma arquitetura aberta, sendo utilizado em aparelhos de diversos fabricantes.

A crescente popularização do sistema também está relacionada ao crescimento do número de aplicativos disponíveis para a plataforma. Muito disso se deve ao fato do uso da linguagem Java como base para desenvolvimento de suas aplicações.

Por essa razão, tanto o programador Java experiente como o iniciante tem um novo e (ainda) relativamente inexplorado mundo a sua volta: o da criação de aplicativos para smartphones e tablets, que utilizem a variada gama de recursos tecnológicos existentes nestes dispositivos.

Como pudemos observar neste artigo, usando o kit de desenvolvimento disponibilizado para download pelo Google, o programador Java tem à disposição ferramentas completas para poder rapidamente se familiarizar com a plataforma e começar a desenvolver novas soluções.

• Site Android Developers
• Documentação oficial dos pacotes do Android SDK (máquina virtual Dalvik).
• Google Play

Confira também