Robozinho Rosa. Muito Fofo !!!

Robozinho Rosa. Muito fofo !!!

Olha o que eu fiz...



Um modelo feminino.

Só tem Robozinho verde, azul. E as meninas ?

Então fiz esse Android rosinha, pois menina também gosta de tecnologia. kkkkkkkk

Espero que achem fofo também.

Até mais!

Layout Android

Layout Android

Olá !

Depois de um bom tempo, voltei !!!

Preparei um post sobre Layout para aplicativos Android.

Como em qualquer sistema, é necessária uma interface gráfica para que haja a interação do usuário. Certo?

É muito mais fácil de organizar e visualizar, declarando elementos da interface em um arquivo XML.

No post “ Entendendo a organização do código no Eclipse “ explica a função de cada classe na estrutura de um projeto Android, inclusive a pastinha Layout, onde fica o main.xml:

- \res\layout: Telas do programa (XML).

Vamos ver um exemplo bem simples de um Layout. Não irei adicionar uma lógica (por enquanto), apenas a interface.

- Criei um projeto chamado TesteLayout;

- Um pacote chamado br.com.android;

- Mudei o nome da Activity para AppTestLayout.

Automaticamente, já é criado o main.xml.

Veja:



Veja que coloquei algumas setinhas coloridas para ressaltar alguns pontos.

Abra a pasta Layout e clique no main.xml (setinha preta).

A setinha da parte inferior (laranja), aponta para o link main.xml, nesta opção, você terá acesso ao código XML, e poderá acrescentar widgets, que são Text, EditText, Button, RadioButton, Checkbox, dentre outros, que a seguir explico como implementar através de códigos ou arrastando esses widgets para o campo que desejar.

Clicando no Graphical Layout (veja a setinha azul), você tem um campo, que é como ficará a aplicação na tela.

A setinha verde, aponta para o item Palette, onde se encontram os widgets, que podem ser arrastados para o campo ao lado (veja a seta preta).

Esses são os tipos de layout, porém, neste post explicarei apenas o LinearLayout.

– LinearLayout

– RelativeLayout

– TableLayout

– FrameLayout

Veja abaixo o código xml que contém o Layout LinearLayout.

Ele empilha ou alinha os elementos filhos na direção horizontal ou vertical e alinha a esquerda, centro ou direita.

<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="@string/hello"

    />

</LinearLayout>

Agora vamos ver como é prático utilizar o Graphical Layout.

Veja as setinhas na figura abaixo...Cliquei na setinha vermelha e arrastei para o campo ao lado (usei o textview). Observe a setinha verde.



Agora vamos para o campo para digitar o textview “Nome”: veja a setinha verde. Clique e digite: Nome.



Veja a setinha amarela, já começamos a montar nossa primeira interface.

Agora já temos um campo para digitar o nome (EditText):



Vamos fazer um textview “Endereço”, é só repetir, como fizemos no Nome ...



Repita também o campo EditText:

Quando você clica em main.xml, o código vai ficar assim:

<?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="@string/hello"

    />

<TextView
android:id="@+id/textView1"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Nome">

</TextView>

<EditText

android:layout_height="wrap_content"

android:layout_width="fill_parent"

android:id="@+id/editText1">

    <requestFocus></requestFocus>

</EditText>

<TextView

android:id="@+id/textView2"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Endereço">

</TextView>

<EditText

android:layout_height="wrap_content"

android:layout_width="fill_parent"

android:id="@+id/editText2">

</EditText>

</LinearLayout>

No próximo post, tem mais Layout. Temos muito ainda que ver.

Até mais !!!

Conhecendo um pouco das Versões Android

Conhecendo um pouco das Versões Android

O Google sempre escolhendo um nome de doce para as suas novas versões e o interessante é que essa escolha segue em ordem alfabética.

Vamos conhecer a seguir um pouquinho de cada versão Android.

Android 1.0 (Setembro/2008)

Esta foi a sua primeira versão e não foi muito difundida, só foi lançada em alguns países.

Android 1.1 (Março/2009)

Foi utilizado apenas para usuários do G1, que era o único celular Android do momento. Nesta versão houve também a correção de alguns bugs.

Android 1.3 – Orange

Não localizei muitas informações a respeito desta versão, porém ouvi dizer que ela existiu.

Android 1.5 – Cupcake (Abril/2009)

Esta versão foi mais difundida e ela ainda é utilizada em aparelhos mais antigos.

Android 1.6 – Donut (Setembro/2009)

Versão que veio com uma nova interface em termos de aplicativos de câmera (foto e vídeo), porém não muito diferente da versão anterior.

Android 2.0/ 2.1 – Eclair (2.0: Outubro/2009 – 2.1: Dezembro/2009)

Versões mais avançadas, comparadas a Donut. Ocorreram várias modificações em sua interface e trouxe novos aplicativos.

Android 2.2 – Froyo (Maio/2010)

Esta versão veio com várias melhorias, possibilitou um aumento de velocidade em seus aplicativos; através do Wi-Fi, compartilhamento de conexão 3G; dentre outros...

Android 2.3 – Gingerbread (Dezembro/2010)

Esta versão melhorou seu gerenciador de downloads e o recurso copiar-colar.

Android 3.0 – Honeycomb (Janeiro/2011)

Versão desenvolvida para tablets.

Android 2.4 – Ice Cream Sandwich (Prevista para o final de 2011)

A Ice Cream Sandwich tem como objetivo unir tablets e smartphones, é a versão melhorada do Honeycomb. Ela pretende unir todos os tipos de gadgets que rodam Android.

Quer conhecer a versão do seu Android ?

Então em seu aparelho clique em CONFIGURAÇÕES => SOBRE O TELEFONE => VERSÃO DO FIRMWARE.

Conheça os aplicativos Android pagos e gratuitos no site Android Market... 

https://market.android.com/

 Até o próximo post.

Entendendo a organização do código no Eclipse

Entendendo a organização do código no Eclipse

No post onde expliquei como criar a primeira aplicação Android (Olá Android), não foi definido a organização do código no Eclipse, como ficam listadas as classes, o main, o XML, ou seja, o que compõe o projeto em si.

Veja a imagem...

No lado esquerdo está definido todo o projeto inicial, onde criamos o pacote que se encontra as classes para execução.

- Nas aplicações Android utilizamos: XML + Java;

- \src:  Fonte Java das aplicações;

- \res\drawable:  Imagens estáticas do programa. (ícones);

- \res\layout: Telas do programa (XML);

- AndroidManifest.xml: Permissões e definições;

- \gen\R.java: Faz a ligação entre o JAVA e o XML. (Atenção ! Ele não pode ser modificado).

Veja no código – Classe: AppOlaAndroid.java:

- Uma observação importante é que toda classe deve ser derivada da Activity;

- O Método principal é: onCreate(Bundle savedInstanceState);

- Para mostrar a página principal: setContentView (R.layout.main);

- @Override é a substituição de métodos, variáveis. (O Eclipse já sugere onde deve se colocar esse tipo de comando).

 Dentro do método onCreate, ele invoca o método onCreate da super classe passando mesmo parâmetro (o savedInstanceState), logo após esse método, temos o método setContentView, responsável por exibir a tela da aplicação, baseado nos layouts xml. Por padrão ele chama o arquivo “main.xml”.

Na pasta PrimeiroProjeto possui um diretório chamado “res”, onde ficam armazenados todos os recursos utilizados pela aplicação. Dentro do diretório “res” existem cinco diretórios, cada um deles com uma finalidade:

- Diretório 1:  “drawable”

Possui três diretórios “drawables” chamados: drawable-hdpi, drawable-ldpi, drawable-mdpi. Todos os três armazenam somente imagens, a diferença de um para o outro é que cada um desses diretórios só será utilizado de acordo com a resolução do Android que você está utilizando (ou seja, qual modelo de emulador você estiver usando).

Ex:

·         Utilizando o diretório “drawable-hdpi” quando é usada a resolução de 480x800 do seu emulador.

·         Utilizando o diretório “drawable-mdpi” quando é usada a resolução 320x480 (resolução padrão do emulador Android).

·         Utilizando o diretório “drawable-ldpi” quando é usada a resolução 240x400.

- Diretório 2: “layout”

Nele é armazenado todos os layouts da aplicação Android, que são os arquivos “.xml”. O main.xml, por padrão, é o arquivo de layout.

- Diretório 3: “values”

Nele é armazenado valores estáticos que podem ser utilizados por um arquivo “.XML”.

Dentro do diretório values, possui o arquivo chamado “AndroidManifest.xml” .

Esse arquivo é a parte principal de uma aplicação Android. É nele que ficam as definições que diz respeito à aplicação.

Veja:

Até o próximo post.

Características e Arquitetura Android

Características e Arquitetura Android

No post anterior, citei o SDK, que é um kit de desenvolvimento e através dele, temos as ferramentas e APIs necessárias para desenvolver aplicações em Java para o Android.

A plataforma Android, possui alguns recursos:

- Application framework: possibilita a substituição e reutilização de componentes.

- Máquina Virtual Dalvik: otimizada para dispositivos móveis.

- Navegador Web Integrado (Browser): baseado na engine open source  webkit.

                                 

- Gráficos Otimizados: possui uma biblioteca 2D e 3D baseada na especificação   

  OpenGL ES 1.0 (aceleração de hardware é opcional).

- SQLite: para guardar dados estruturados, ou seja, armazenar dados no formato de estruturas relacionais.

- Suporte multimídia: para vídeo, áudio e formatos de imagem (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, compasso, e acelerômetro (dependente de hardware).

- Rico Ambiente de Desenvolvimento: incluindo um emulador de dispositivo, ferramentas de depuração, analisador de memória e performance, e um plugin para o Eclipse (ADT).

Arquitetura Android

De acordo com a figura, podemos visualizar a estrutura da arquitetura Android que é dividida em camadas: Applications, Application Framework, Libraries, Android Runtime e Linux Kernel.

Applications: Localiza-se nesta camada, um conjunto de aplicações padrões, como - um cliente de e-mail, programa de SMS, calendário, mapas, navegador, contatos, agenda, entre outros (todos desenvolvidos em Java).

Application Framework: Esta camada enfatiza a reutilização de código, pois é nesta camada que se encontram os componentes que permitirão que novas estruturas sejam utilizadas futuramente. Abaixo o conjunto de componentes desta camada:

* Um rico e grande conjunto de componentes gráficos que podem ser utilizado para construir uma aplicação, e também 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 (Ex: Contatos) 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 deslocados para liberar memória.

Libraries e Android Runtime: Nesta camada, encontram-se as bibliotecas escritas em C/C++e o ambiente de execução (Composta pelas bibliotecas e pela máquina virtual Dalvik). Toda aplicação Android roda em seu próprio processo, com sua própria instância da máquina virtual.

- System C library (Biblioteca de Sistema C) – uma implementação derivada da biblioteca C padrão sistema (libc) do BSD sintonizada para dispositivos rodando Linux.

- Media Libraries (Bibliotecas de Mídias) – baseado no PacketVideo’s OpenCORE; as bibliotecas suportam a maioria dos formatos de áudio e vídeo, imagens como MPEG4, H.264, MP3, AAC, AMR, JPG, e PNG.

- Surface Manager (Gerenciador de Superfície) – gerencia o acesso ao subsistema de exibição bem como as múltiplas camadas de aplicações 2D e 3D.

- LibWebCore – um web browser engine utilizado tanto no Android Browser quanto para exibições web.

- SGL – uma engine de gráficos 2D.

- 3D libraries – uma implementação baseada na especificação OpenGL ES 1.0 APIs, as bibliotecas utilizam aceleração 3D via hardware (quando disponível) ou o software de renderização 3D altamente otimizado incluído no Android.

- FreeType – renderização de fontes bitmap e vetoriais de fontes.

- SQLite – um poderoso e leve engine de banco de dados relacional disponível

para todas as aplicações.

Linux Kernel: Esta é a base da camada. O Kernel também atua como uma camada de abstração entre o hardware e o software. É utilizada a versão 2.6, onde fornece serviços do sistemas, como segurança, gerenciamento de memória, gerenciamento de processos, pilhas de redes, etc.

A tabela abaixo apresenta as principais APIs Android

Nossa !!! Haja teoria.

No próximo post, vamos entender a organização do código no Eclipse.

Até breve !