Tutorial Instalação, configuração e exemplo de app Android

Clique aqui para baixar o trabalho na íntegra, apresentação e código da aplicação desenvolvida(.zip e .apk).


A SEGUIR UM PASSO A PASSO PARA O DESENVOLVIMENTO DE UMA APLICAÇÃO ANDROID HELLO WORLD.

PASSO 01

Primeira coisa a ser fazer para trabalhar com Android é ter o Java instalado na máquina (já que o Android trabalha com o Java).

Se não tiver basta apenas baixa-lo no site da Oracle no seguinte endereço: http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u3-download-1501626.html e escolher a JDK de acordo com o seu sistema operacional. A imagem abaixo mostra o respectivo site.

PASSO 02

Depois necessitaremos (no nosso caso) a ferramenta Eclipse. Que pode ser obtida no seguinte endereço: http://www.eclipse.org/downloads/

OBS: Aconselhamos baixar o Eclipse Classic. Por ter poucos recursos (apenas o essencial), ficando dessa forma, uma ferramenta mais limpa e rápida para se trabalhar com o Android. Na hora de baixar o Eclipse basta apenas o usuário escolher qual a versão do SO. A figura abaixo mostra o site do Eclipse.

PASSO 03

Agora é necessário baixar a SDK do Android para desenvolver as aplicações. Pode ser baixada no seguinte endereço: http://developer.android.com/sdk/index.html e escolher a SDK de acordo com o sistema operacional que será utilizado para o desenvolvimento.

Após se baixado a SDK, basta descompactar em alguma pasta de sua preferência. Caso o SO utilizado for o Windows e a SDK baixada for à de formato executável, basta seguir os passos descritos logo abaixo:

Clicar em Next. Após isso aparecerá a seguinte tela mostrada abaixo:

Novamente basta clicar em Next. Aqui ele verifica onde está localizada a JDK do Java. Caso a pessoa não o tenha instalado em sua máquina, não será permitido prosseguir com a instalação. A próxima tela informa o diretório onde será instalada a SDK do Android. Podendo deixar o default ou algum outro diretório que o usuário julgue necessário. Após isso será mostrada a seguinte tela:

Não se faz necessário nenhuma alteração. Bastando apenas clicar em Install. Durante o processo de instalação é exibida a seguinte tela:

Tela de término da instalação é exibida da seguinte maneira:

Após o término da instalação, clicando em Next, a seguinte tela é exibida ao usuário:

Aqui desmarcaremos o checkbox e clicaremos em Finish. Optamos por desmarcar o checkbox porque iremos demonstrar como configurar, baixar o emulador e alguns arquivos necessários para o funcionamento da SDK do Android pelo Eclipse.

PASSO 04

Agora é necessário instalar e configurar um plugin específico para que possamos utilizar o Android dentro do Eclipse. Com o Eclipse aberto ir a Help > Install New Software....

Aparecerá a seguinte tela:

Após isso clicar no botão Add... Na tela exibida preencher com os seguintes dados:

OBS: Em Name pode ser qualquer nome que identifique aquela URL.

Clicar em OK. Após isso aparecerá à tela mostrada logo abaixo, bastando apenas marcar os checkboxs e clicar em Next.

Após calcular as dependências necessárias, aparecerá a seguinte tela:

Clicar em Next. E será exibida a seguinte tela:

Selecionar I accept the terms of the license agreements e clicar no botão Finish. Agora é só aguardar baixar o plugin e esperar que o Eclipse configure o mesmo na sua IDE. Durante o processo será demonstrada a seguinte tela:

Após o término da instalação, o Eclipse irá pedir para restartar a aplicação. Para isso basta clicar em Restart Now.

Quando o Eclipse for reiniciado aparecerá a seguinte tela:

Caso já tenhamos instalado a SDK do Android (demonstrada no Passo 03), é só escolhermos a segunda opção Use existing SDks e selecionar o diretório onde foi instalado o mesmo. Caso não tenha instalado a SDK basta marcar a primeira opção Install new SDK que o Eclipse se encarregará de instalar a mesma. Como já tínhamos instalado a SDK selecionaremos a segunda opção e clicamos em Next.

A figura abaixo informa se desejamos participar da pesquisa de estatística do Google. Como não temos interesse selecionamos No e clicamos em Finish.

Será exibida a seguinte janela de informação:

Clicamos em Open SDK Manager e é exibida a seguinte tela:

Essa tela informa quais plataformas de Android iremos trabalhar e pacotes a serem instalados. Para nossa aplicação iremos apenas deixar marcados os Default e iremos adicionar/marcar o Android 2.3.3 (visto que hoje é a versão mais utilizada no smartphones do mercado) e o checkbox referente à opção Extra. A figura abaixo demonstra isso:

Após isso, é só clicarmos no botão Install 28 packages... (lembrando que isso pode aumentar de acordo com o que selecionarmos). Irá aparecer a seguinte tela:

É só clicar em Install e esperar o processo de download e configuração dos pacotes selecionados. A figura abaixo mostra o programa realizando o download dos arquivos selecionados, bem como as suas dependências:

Tela de Log que demonstra o que está se passando no decorrer da instalação.

Após o término é exibida o seguinte informativo:

Basta clicar em OK e depois Close na tela demonstrada logo abaixo:

E depois basta clicar no X (no canto superior direito da tela) na janela do Android SDK Manager e fechar o Eclipse.

PASSO 05

Próximo passo é criar um dispositivo de gerenciamento virtual (emulador ou AVD). Permite visualizar a aplicação como se estivesse em um dispositivo real. Vamos lá: Ir em Window->AVD Manager. Irá aparecer a seguinte janela:

Clicar no botão New para criar um novo AVD. Aparecerá a seguinte janela:

Em Name, damos um nome ao nosso AVD/Emulador;

Em Target, a versão que utilizaremos do Android;

Em SD Card, colocar um valor entre 9 e 1023 MiB(significa a memória utilizada pelo emulador);

Em Skin colocar o default mesmo.

E clicar em Create AVD.

Exemplo:

Depois é só fechar do Android Virtual Device Manager clicando no X (no canto superior direito).

APLICAÇÃO ‘HELLO WORLD’

Vamos demonstrar agora uma aplicação exemplo que irá imprimir no emulador/AVD do Android uma mensagem de Hello Word. Para isso basta seguir os seguintes passos:

• Executar o Eclipse
• Ir em New->Other...

• Selecionar a pasta Android e escolher a opção Android Project. Depois clicar em Next

• O próximo passo é escolher um nome para o projeto. Para o nosso exemplo escolhemos o nome HelloWord. Clicar em Next.
  
  
  

  

  
  

• A próxima tela é necessária informar qual versão do Android que iremos trabalhar. Para esse exemplo utilizamos a versão 2.3.3. Na figura abaixo, só estão sendo mostradas duas versões do Android. Mas pode acontecer de aparecer mais opções de versões. Isso acontece na hora que selecionamos os pacotes no Android SDK Manager demonstrado no Passo 04. Basta clicarmos em Next.
  
  
  

  

  
  

• Será exibida a tela conforme mostrada logo abaixo. Nela escolhemos o nome do nosso pacote (Package Name). As demais opções não se faz necessária alteração clicando em Finish para finalizar a criação do projeto.
  
  
  

  

  
  

• Após a finalização da criação do projeto o mesmo será mostrado no Package Explorer do Eclipse. Como demonstra a figura logo abaixo.
  
  
  

  

  
  

• Para executar a aplicação de exemplo basta clicarmos com o botão direito do mouse e ir à opção Run As->Android Application, conforme ilustrado na imagem logo abaixo:

Outra forma de executar a aplicação é clicar na setinha verde (Run as) e escolher a opção Android Application e no botão OK. A figura abaixo demonstra isso:

• É exibida uma tela semelhante à figura abaixo. Essa tela representa uma simulação de um aparelho de smartphone. Para que apareça a mensagem Hello Word é necessário aguarda certo tempo (demora um pouco).
  
  
  

  

  
  

• Após o carregamento total do emulador eis que aparece a mensagem esperada.
  
  
  

  

  
  

Bom, é isso!

Gitbook em português brasil em formato PDF

Olá,

Estou aqui mais uma vez trazendo o resultado de um trabalho que viemos realizando desde o final de 2008, a versão PDF em português do livro The Git Community Book criado por Schacon (schacon@gmail.com), hospedado no Github em http://github.com/schacon/gitbook.

Finalmente consegui instalar os gems que os scripts precisavam para gerar o PDF.

Aviso desde já, que este livro encontra-se em constante mudança, através de correções, atualizações e adição de novos conteúdos, então, você ainda pode encontrar trechos ou capítulos inteiros em inglês.

Por fim confira a versão traduzida fazendo o download aqui.

Quem quiser contribuir pode juntar-se a comunidade começando pelo projeto original.

Livro git-scm em português

Para quem tem interesse em aprender mais sobre Git , existe um projeto de tradução do livro git-scm para o português, baseado no site www.git-scm.com mantido por Scott Chacon.
O livro ainda precisa de revisão (voluntários para revisão não deixem de acessar), mas o seu conteúdo já permite o aprendizado sobre as funcionalidades do Git.
Ele ainda encontra-se incompleto em alguns capítulos, definição de termos, exemplos entre outros.
Se você tem interesse em aprender ou contribuir com o projeto de tradução acesse http://github.com/schacon/gitbook/tree/pt_BR.
O meu fork do projeto está em http://github.com/djalmaoliveira/gitbook/tree/pt_BR e já está com um tradução completa do livro, mas lembrando novamente, de que precisamos de revisores.

Criptografia é Matemática (uma inocente visão)

Continuando a leitura(3º capítulo) do livro "O último teorema de Fermat", pude conhecer além das trágicas hitórias da vida de alguns matemáticos além de mulheres que ofereceram uma grande contribuição para a matemática mas não foram reconhecidas, o princípio de funcionamento da criptografia de chave pública e privada a partir dos estudos de Euler.

Imagine a chave como se fosse uma senha, senha essa usada para codificar e decodificar algum texto usando um determinado algoritmo(não importa qual algoritmo é usado nesta explicação).

Segundo o livro conta, os matemáticos procuravam uma forma de criar 2 chaves, a primeira que fosse fácil de criar e a segunda, baseada na primeira, que fosse quase impossível de ser recriada / deduzida.

A segunda chave, a pública(onde todos podem saber), seria usada para gerar um texto codificado(ainda não importa o algoritmo usado) no qual somente quem detem a primeira chave poderia decodificá-la.

Como gerar essas chaves?
Vejamos um exemplo:
Escolhemos 2 números: 5 e 17
Multiplicamos eles entre si : 5 x 17 = 85

O número 85 seria a chave pública divulgada e o 5 e 17 (que juntas geram o 85) seria a chave privada (somente o dono a possui).

Então neste momento podemos deduzir a partir do número 85 qual seria os 2 números que multiplicados entre si se igualasse a 85 (é claro que você deve considerar que não conhece a chave privada que foi citada acima)?

Existem algumas possibilidades além da chave original 5 e 17.

A quantidade de possibilidades de combinações mostra o quanto uma chave(privada) pode ser forte (capacidade de deduzí-la através de tentativa e erro), quanto maior o número maior a possibilidade.

É claro que não utilizariamos números pequenos numa aplicação real, mas números muito grandes com 80 a 100 digitos(por exemplo, é claro que pode ser maior) cada um dos 2 termos da multiplicação(chave privada).

E para dificultar mais ainda usaríamos números primos, ou seja, teríamos que computar primeiros os 2 números primos grandes antes de efetuar a multiplicação e gerar a chave pública.

Números primos tão grandes assim poderiam fazer com que sistemas computacionais levasse anos para descobrir qual combinação de 2 primos muito grandes multiplicados dão como resultado a chave pública por tentativa e erro.

E ainda segundo o texto, essa chave poderia ser alterada frequentemente(a cada ano por exemplo), para que desmotive quem esteja tentando calcular, via tentativa e erro, a chave privada a partir da pública, forçando-o a iniciar novamente todo o processo.

Essa dificuldade se dá pelo fato das características dos números primos, que são números divisíveis por 1 e por ele mesmo apenas.

Provavelmente devem existir algumas formas de acelerar estas buscas, como por exemplo, uma catalogação dos números primos, ou algum outro método que desconheço.

Bom, dadas a minhas humildes experiências com criptografia e seus métodos atuais de funcionamento e matemáticos, esse é minha pequena contribuição para os interessados nesse assunto.

Até a próxima !

Um simples problema matemático

Lendo os 2 primeiros capítulos desse interessante livro "O último teorema de Fermat" (para os leigos, assuntos sobre a origem das fórmulas matemáticas e outros assuntos históricos matemáticos) pensei como poderia resolver esse simples problema:

Sendo a raiz quadrada de 2 um número irracional(números com infinitas casas decimais), como a multiplicação da raiz quadrada de 2 por ela mesma( raiz quadrada de 2 ao quadrado ) é o número 2 como resultado?

Uma multiplicação entre números é na verdade uma sequência de somas, por exemplo:

4 x 3 = 12

mais didaticamente:

4 + 4 + 4 = 12
ou
3 + 3 + 3 + 3 = 12

Então como a multiplicação de 2 números irracionais iguais é o próprio número sem a raiz.

Isso me faz pensar que os números irracionais não são infinitos.

Bom, meus conhecimentos sobre as definições e convenções matemáticas não são extremamente grandes, na realidade são muitos básicas(só o que aprendi no colegial) e não conseguem entender esse fato, mas será que existe alguma explicação para este simples problema.

Que tal calcular todas as casas decimais de um núumero irracional? Mas eles são infinitos, e agora?

Obs.: Estou considerando aqui somente números inteiros como resultado, é claro que a soma de irracionais pode chegar bem próximo do valor inteiro.

Se você quer saber a história dos postulados matemáticos e seus desafios, este é um bom livro para começar.

Tutorial Git - Atualizado

Nova versão do Tutorial, caso prefira a versão em pdf clique aqui!




TUTORIAL PRÁTICO SOBRE Git

por Djalma Oliveira

Versão 1.1



"Git é um sistema de controle de revisão distribuida, rápido e escalável" (tradução rápida do manual).
Basicamente é um sistema de controle de versionamento de arquivos, muito usado por desenvolvedores para gerenciar versões do software produzidos seja por um desenvolvedor como também por outros participantes do projeto.
Com ele podemos integrar novas funcionalidades efetuadas por outros desenvolvedores, completa, parcial ou não, e tudo isso sendo registrado em um histórico que permite "voltar no tempo" para descobrir por exemplo como funcionava uma determinada versão daquele projeto. Os participantes do projeto podem enviar suas versões, correções, patchs para o projeto principal sem que o projeto principal seja comprometido, permitindo ao dono do projeto a escolha, teste e inclusão dessas alterações no projeto principal se desejar.
O Git foi desenvolvido inicialmente por Linus Torvalds mediante uma necessidade de ter um software robusto para controle de versão do kernel linux.
Outras informações sobre o assunto pode ser acessado através desses links:

Projeto : http://git.or.cz/
Vídeo do Linus falando sobre o Git: http://www.youtube.com/watch?v=4XpnKHJAok8
Manual do usuário: http://www.kernel.org/pub/software/scm/git/docs/user-manual.html

Aqui iniciaremos um rápido e prático tutorial sobre o Git, nada muito profundo, mas bastante útil para aqueles que queiram entender um pouco sobre Git.


TERMOS ANTES DE COMEÇAR


Repositório: Local onde fica armazenado os arquivos do projeto, versões e históricos, local onde os desenvolvedores podem submeter as alterações para o projeto.

Commit: Conjunto de alterações realizadas durante o desenvolvimento, normalmente essas alterações são implementações específicas, seja uma correção, nova versão entre outros. Veja um commit como um ponto histórico no desenvolvimento do projeto, esses pontos podem ser recuperados quando necessário.



INICIANDO UM REPOSITÓRIO LOCAL


Criaremos uma pasta para nosso repositório:
mkdir meuprojeto
cd meuprojeto

Dentro da pasta iniciaremos um repositório Git:
git init

Perceba que todos os arquivos dentro da pasta(meuprojeto) fazem parte do repositório, ou seja o seu projeto.

Configuramos agora as informações sobre o desenvolvedor(você), usado para identificar o desenvolvedor em cada commit realizado:
git config user.name "Djalma Oliveira"
git config user.email "djalmaoliveira@gmail.com"

Perceba que foi criado uma pasta '.git', aonde todas as informações e históricos dos arquivos ficam armazenados e onde acontece a 'mágica'.

Criamos dois arquivos(vazios) para o projeto.
touch arq1.txt
touch arq2.txt

Agora informamos ao Git que todos os arquivos devem ser incluidos ao próximo commit:
git add .

Mas se desejar também pode adicionar somente arquivos específicos, basta informar o seu caminho:
git add arq2.txt

O Git é inteligente o suficiente para detectar se houve alguma alteração nos arquivos que foram indicados para o commit(git add), assim ele não realiza commits sem que pelo menos um arquivo tenha sido alterado, exceto o primeiro commit.

Agora realizamos o commit:
git commit -a -m "Meu primeiro commit"

* o parâmetro -a informa que deve adicionar todos os arquivos alterados ao commit;
* o parâmetro -m "texto" adiciona uma mensagem informativa para o commit;


Resumindo, para realizar commits seguimos 3 passos:
1 - Efetuar modificações em algum arquivo;
2 - Informar ao Git quais arquivos devem ser adicionados ao próximo commit(git add);
3 - Efetuar o commit(git commit) propriamente dito baseado nos arquivo do passo 2;

No Git todo commit, exceto o primeiro, é descendente(filho) de um outro commit, então você pode verificar diferenças entre commits caso queira.

Após eleger(git add) quais arquivos irão para o próximo commit, você pode ver quais alterações foram realizadas desde o último commit, usando:
git diff --cached

Essas informações sobre alterações desde o último commit ficam armazenadas em uma estrutura do Git chamada de 'index', ou seja, todas as vezes que você adicionar(git add) arquivos para o próximo commit essas diferenças ficam armazenadas nessa estrutura até o momento em que de fato seja realizado o commit(git commit).

Listando commits realizados:
git log

Mostrando os arquivos alterados desde o último commit:
git status

Mostra as alterações realizadas no último commit:
git show






BRANCHS


Uma branch é uma linha de desenvolvimento do projeto. Você pode ter vários branchs em seu repositório, cada branch representando uma versão específica de seu projeto, por exemplo. Veja um branch como um fork('cópia') do projeto que pode seguir sua própria linha de desenvolvimento.
Todo novo repositório Git (após o primeiro commit) possue um branch chamado por padrão 'master'.

Por exemplo podemos reprensentar nossos branchs da seguinte forma:
master => projeto principal e a última versão em produção.
working => branch no qual você está trabalhando atualmente;
versao-1.0 => uma das várias versões disponíveis de seu projeto.
versao-1.1 => outra versão...
teste => alguma versão para testes



MANIPULAÇÃO DE BRANCHS LOCAIS

Listando os branchs locais:
git branch

* master
teste
working

Perceba que o branch que possui um '*' na frente representa o branch corrente.

Criamos um novo branch 'working' baseado no branch corrente, mantendo-se no branch atual(master):
git branch working

Criando um novo branch 'teste' baseado em um outro branch 'working' que não é o corrente,ainda mantendo-se no branch atual:
git branch teste working

Outra forma de criar um branch e ao mesmo tempo tornar o novo como corrente é usando:
git checkout -b teste working

Até este ponto devemos ter as seguintes branchs:
* master
teste
working

Mudando para o branch working:
git checkout working

Agora ficará assim:
master
teste
* working

Apagando um branch:
git branch -D teste

Lembrete: você não pode apagar o branch corrente, alterne para um outro então execute novamente o comando.




MAIS SOBRE OS BRANCHS

Até aqui você já deve ter percebido que não foi necessário sair da pasta do projeto, na realidade a cada mudança de branch (git checkout) os arquivos contidos na pasta do projeto são modificados para refletir exatamente as versões de cada branch, sendo assim o seu projeto sempre vai estar localizado naquela pasta, pois o Git se encarrega de gerenciar as informações relativos a cada branch corrente.




INCORPORANDO(merge) NOVAS MODIFICAÇÕES AO PROJETO


Uma das funcionalidades mais interessantes do Git é a capacidade de incorporar as alterações realizada por programadores ao projeto. Essa 'junção' se dá somente entre branchs e é chamada de merge.

Por exemplo, digamos que o arquivo arq2.txt no branch working foi alterado:
git checkout working # mudando para o branch working
echo "opa" > arq2.txt # alteração propriamente dita
git add . # marca os arquivos para o próximo commit
git commit -a -m "alterando arq2.txt" # commit

Agora a idéia é adicionar as alterações realizadas no branch working para o branch master(lembre-se que o branch working é um fork do master!?).

Mudamos para o branch que receberá as alterações:
git checkout master

Realizamos agora o merge das alterações do branch working para o corrente(master):
git merge working

Após o comando acima será mostrado um resumo do que foi realizado:
Updating 751bee8..625fa43

Fast forward
arq2.txt | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)

Confirmando a alteração no arquivo:
cat arq2.txt

Peceba que neste momento toda e qualquer alteração realizada no último commit do branch working agora está refletida do branch master, inclusive o commit realizado na branch working, que agora está na branch master.

Verifique o último commit:
git log



COMPLICANDO MAIS

Perceba que antes de efetuarmos o merge, somente a branch working possuia alterações, a master não, mas e se a branch master fosse alterada antes de dar-mos um merge a branch working?

Essa situação é bastante comum em projetos grandes que alterações são adicinadas frequentemente ao projeto principal, não refletindo mais a versão atual do working.
“Lembrando que todo branch possui um branch pai que é a sua base a partir de então.”
Nessa situação a melhor forma de realizar o merge seria realizar um 'rebase', ou seja, pegar o último commit do master, que é a base do working (por isso o nome rebase), trazer para o working e aplicar todos os seus commits(na mesma ordem de criação) nele, agora sim a sua versão do working estará sincronizada com a última versão do master mais os seus commits.

Realizar um merge nessa situação pode até funcionar(o Git é inteligente em algumas situações), mas não é recomendado pois isso poderia causar conflitos que seriam mais trabalhosos de resolver do que se efetuasse um 'rebase'.

Então antes de aplicar-mos um merge ao master, faremos um rebase a branch working antes para refletir a última versão do master:
git checkout working
git rebase master

Agora podemos aplicar um merge ao master:
git checkout master
git merge working



REPOSITÓRIOS REMOTOS

A idéia é a mesma de um repositório local, mas os remotos são hospedados em servidores na internet ou outra máquina que não a sua (mas pode ser a sua também).
Para trabalharmos com repositórios remotos usamos alguns comandos extras além dos já estudados.

Para criar um clone (cópia de todo o projeto, incluindo todos commits) do projeto podemos usar um dos seguintes comandos (dependendo a configuração do servidor):
git clone git://sitehospedado.com.br/projeto
ou
git clone http://sitehospedado.com.br/projeto

Logo após, você verá que será criado um diretório com o nome do projeto, e dentro a cópia(clone) de todo o projeto.

Veja o repositório remotos disponível agora:
cd projeto
git branch –r

origin/HEAD
origin/master
origin/working

Perceba que a palavra origin é o nome padrão (mas você pode criar um com nome diferente desse se quiser) para repositórios remotos, representando os branchs que existem no projeto, mas que são de origem remotas para você agora.
Veja que você deve criar um branch local baseado em algum branch remoto antes de começar a efetuar suas alterações.
git checkout –b working origin/working

Agora digamos que você efetuou várias alterações neste repositório e durante esse tempo o projeto principal também foi alterado não correspondendo mais a base que você possui agora e então deseja sincronizar com a última versão disponível do projeto.

Primeiramente recuperamos a versão recente do projeto:
git fetch

Agora efetua o merge com o branch atual:
git merge origin/master

Uma outra forma de realizar poderia ser assim:
git pull origin master

Ou até mesmo:
git pull

Neste último caso considerando que você tem um branch master ele fará o merge automaticamente.
SINCRONIZANDO SUAS ALTERAÇÕES COM O REPOSITÓRIO REMOTO

Após efetuar suas modificações no branch, você pode enviá-lo para o servidor remoto através deste simples comando:
git push








INFORMAÇÕES FINAIS


Bom, finalizo por aqui mas existem ainda muitos comandos sobre o Git que podem ser abordados em versões futuras deste manual, então aguardem atualizações.

Espero ter abordado de forma clara, algumas características do Git e comentem se encontrarem algum erro, pois algumas partes foram traduzidos(minha versão) do manual do usuário.

Tutorial prático sobre Git

Esse tutorial tem a intenção de abordar as principais características do Git, nada profundo, mas suficientemente prático para que você possa ter uma visão geral de como utilizar os seu comandos.


Para acessar clique aqui






.