Saudações a todos!!!

O objetivo deste artigo é demonstrar que algumas práticas de engenharia (como um bom design de domínio, refactoring e TDD) são peças fundamentais para que possamos colher os benefícios das metodologias ágeis. Vamos começar voltando um pouco no tempo e explicar como era o mundo antes das práticas ágeis:

Crise do Software

A “crise do software” foi um termo cunhado para descrever as dificuldades enfrentadas no desenvolvimentode software no fim da década de 60. A complexidade dos problemas, a ausência de técnicas bem estabelecidas e a crescente demanda por novas aplicações começavam a se tornar um problema sério. Foi nessa época, mais precisamente em 1968, que ocorreu a Conferência da OTAN sobre Engenharia de Software (NATO Software Engineering Conference) em Garmisch, Alemanha. O principal objetivo dessa reunião era estabelecer práticas mais maduras para o processo de desenvolvimento, por essa razão o encontro é considerado hoje como o nascimento da disciplina de Engenharia de Software.

NATO Software Engineering Conference 1968

Duas décadas depois, em 1986, Alfred Spector, presidente da Transarc Corporation, foi co-autor de um artigo comparando a construção de pontes ao desenvolvimento de software. Sua premissa era de que as pontes normalmente eram construídas no tempo planejado, no orçamento, e nunca caiam. Na contramão, os softwares nunca ficavam prontos dentro do prazo e do orçamento, e, além disso, quase sempre apresentavam problemas.

Custo das mudanças

Uma das consequências de tentarmos igualar metodologias de desenvolvimento de software a metodologias de engenharia tradicionais (como construção civil) é a visão de que o custo de modificar o programa aumenta exponencialmente ao longo do tempo, conforme gráfico abaixo:

Acolhendo as mudanças

A partir da metade dos anos 90 começaram a surgir discussões sobre se a forma faseada acima (cascata), como ocorre na construção civil era realmente o melhor modelo para o desenvolvimento de software???? As metodologias ágeis de desenvolvimento surgiram exatamente para permitir maior flexibilidade no processo de desenvolvimento de sistemas e minimizar o custo de mudanças ao longo dos projetos, fazendo com que o gráfico acima fique mais próximo do apresentado abaixo:

Mas afinal de contas, como isto é possível? Como podemos adicionar mudanças ao software sem implicar em altos custos para o mesmo? A reposta a esta pergunta é o título do artigo: Aplicando boas práticas de engenharia!

Muitos times adotam Scrum, mas deixam de lado as boas práticas de engenharia que são necessárias para que seja possível acolher as mudanças ao longo do projeto como pregam as metodologias ágeis. Este tipo de problema já foi discutido por Martin Fowler James Shore . E meu objetivo com este post é despertar estes times para o estudo de práticas de engenharia como refatoração, boas práticas de design de domínioTDD .

Se você usa scrum, mas não utiliza estas práticas, sugiro que comece com urgência a estudar estes assuntos.

Um bom caminho para iniciar são os 3 livros abaixo:

Fonte: Blog Ricardo Fernandes Luiz

 

Delphi Meeting 2011

Posted: February 8, 2011 in Uncategorized

Delphi Meeting 2011

Evento será realizado em diversas cidades

O Delphi Meeting 2011 é uma ótima oportunidade para você aprimorar seu conhecimento técnico e se reunir com outros profissionais da área.

Este ano você irá aprender do início ao fim, como criar aplicações de qualidade com Delphi XE e DataSnap, além de conhecer o novo suporte para o desenvolvimento de aplicativos para iPhone, iPad e Linux com Delphi Prism.

O evento, que tem inscrição gratuita, será realizado em diversas cidades como São Paulo, Recife, Goiânia, Fortaleza, João Pessoa, Rio de Janeiro e outras.

Em São Paulo, o evento será realizado no dia 15 de fevereiro de 2011 no Renaissance São Paulo Hotel das 9 da manhã às 13 horas.

Clique aqui para fazer sua inscrição para o evento de São Paulo  e aqui para ver as outras datas e cidades onde o Delphi Meeting 2011 será realizado.

 

ou Acesse: http://bit.ly/F4Sfs

 

 

Fonte: http://bit.ly/eFvs62

 

[Curso presencial] ASP.NET MVC

Posted: January 24, 2011 in Uncategorized

Descrição:

O ASP.NET.MVC é a Framework da Microsoft para o desenvolvimento de aplicações web, utilizando o padrão de Projeto MVC, no qual possui todos recursos necessários para construir e implementar aplicações robustas em nível profissional para Web. O curso irá Oferecer todo conhecimento necessário para o aluno aplicar e trabalhar com ASP.NET MVC em seu projetos e utilizando das melhores práticas.

Objetivo:

Orientar o aluno de forma teórica e prática sobre as características da tecnologia ASP.NET MVC 2.0 , utilizando como ferramenta de desenvolvimento o Visual Studio 2010. Ao final do treinamento o aluno será capaz de desenvolver aplicações WEB com ASP.NET MVC utilizando os principais recursos da ferramenta e da tecnologia abordada. Esse treinamento aplica a prática baseada em experiências profissionais e didática do instrutor.

Beneficios:

■   Certificado ao final do Curso
■    Instrutor  certificado, com experiência e didática

Investimento:

■  500,00
Somente para pagamentos por transferência ou depósito (Para informações sobre essa forma de pagamento solicite maiores informações enviando email para:atendimento@moacircasemiro.com

■   560,00
( Para pagamentos com boleto ou Cartão de Crédito via PagSeguro)

Formato:

■  Presencial

Horário:

■   08:30 às 12:30 e 13:30 18:30

Data:

■   12/02 , 19/02, 26/02

Carga Horária :

24 horas

Local do Treinamento :

Telefone de contato : 88675477

Rua Cel Linhares, 950 – Salas 1007 e 1008
Atrás da Gastroclinica

Para mais informações :

através dos email: atendimento@moacircasemiro.commoacircasemiro@hotmail.com
msn : moacircasemiro@hotmail.com

Ementa :
Módulo  1: Introdução

Item 1 : Plataforma ASP.NET
Item 2 : Caracteristicas de um aplicação ASP.NET
Item 3 : Entendendo Web Forms
Item 4 : Padrão de Projeto MVC
Item 6 : Web Forms versus MVC
Item 7 : Prática

Módulo  2: ASP.NET MVC

Item 1 : Introdução
Item 2 : Caracteristicas do ASP.NET MVC
Item 3 : Introdução a Roteamento
Item 4 : Introdução a Camada de Modelo
Item 5 : Introdução a Camada de Visualização
Item 6 : Introdução a Camada de Controle
Item 7 : Helpers
Item 8 : Testes
Item 9 : Prática

Módulo  3: RoteamentoItem 1 : Definindo Rotas
Item 2 : Areas
Item 3 : StopRoutingHandler e IgnoreRoute
Item 4 : Debugging
Item 5 : Prática

Módulo  4: Modelo

Item 1 : Introdução
Item 2 : Convenções da Camada de Modelo
Item 3 : Construindo uma camada de modelo
Item 4 : Binders�
Item 5 : FormCollection
Item 6 : Utilizando Parametros
Item 7 : Camada de Modelos e Entity Framework
Item 8 : Utilizando Object Context
Item 9 : Prática

Módulo  5: Controllers

Item 1 : Introdução
Item 2 : Routeamento e a Controler
Item 3 : Classe Base ControllerBase
Item 4 : Interface IController
Item 5 : DefaultControllerFactory
Item 6 : Actions
Item 7 : Selector Filters
Item 8 : Model Binding
Item 9 : Action Filters
Item 10: Customizando um Action Filter
Item 11: Prática

Módulo  6: Views

Item 1 : Introdução
Item 2 : Convenções
Item 3 : Utilizando Master Pages
Item 4 : View Content
Item 5 : HTML Helpers
Item 6 : Customizando Helpers
Item 7 : View Data
Item 8 : Partial Views
Item 9 : Validação
Item 10: Encodes Automaticos
Item 11: RenderAction
Item 12: HTML Template Helpers
Item 13: Data Annotations
Item 14: Metadata e Templates
Item 15: Prática
Módulo  7: AJAXItem 1 : Introdução
Item 2 : Gerenciando Scripts
Item 3 : AJAX Helpers
Item 4 : AJAX Options
Item 5 : Tratamento de Erro
Item 6 : Utilizando  Partials para renderizar
Item 7 : AutoComplete
Item 8 : Implementando  AutoComplete com Microsoft ASP.NET Ajax
Item 9 : Filtrando dados com Selectbox
Item 10: Modal Pop-Up com jQuery
Item 11: Controle Rating
Item 12: Prática

Módulo  8: Filtros

Item 1 : Incluindo Filtros com ASP.NET MVC
Item 2 : Authorize
Item 3 : RequireHttps
Item 4 : OutputCache
Item 5 : Exception Filter
Item 6 : Custom Filters
Item 7 : Customizando Action Filter
Item 8 : Customizando  Authorization Filter
Item 9 : Customizando  Exception Filter
Item 10: Prática

Módulo  9: SegurançaItem 1 : Introdução
Item 2 : Importância de ter uma aplicação segura
Item 3 : Spam
Item 4 : Cross-Site Scripting (XSS )
Item 5 : Cross-Site Request Forgery
Item 6 : Cookie
Item 7 : Over-Posting
Item 8 : Prática

Mais informações Acesse: http://bit.ly/eKhLSp

twitter.com/moacircasemiro

Razões para estudar Android

Posted: January 19, 2011 in Uncategorized

A área de tecnologia da informação é peculiar pela velocidade com que as coisas mudam ou evoluem. Novas linguagens mais eficientes e simples, frameworks que prometem alavancar sua produtividade, metodologias que se propõem a dar um direcionamento adequado ao time de desenvolvedores, ferramentas fantásticas com seus plugins que facilitam nossa vida, novas mídias que surgem com grande potencial para o futuro… ufa!!! Ficamos desorientados com tantas possibilidades.

Como simples mortais, precisamos escolher um caminho para trilhar. Não podemos estudar tudo ao mesmo tempo, precisamos fazer escolhas. Mesmo com um ramo principal bem definido, como “Programação Java para Web“, ainda temos dificuldade em direcionar nossas pesquisas para um determinado framework ou outro. Claro que no mundo real, temos que estudar aquilo que as empresas em que trabalhamos estão utilizando nos seus projetos. Mas somos seres muito inquietos, sedentos por desafios, e não gostamos de fazer a mesma coisa durante muito tempo. Um bom desenvolvedor está sempre preocupado em fazer melhor aquilo que já faz, e procurando aprender algo que ainda não sabe. Foi esta filosofia que me levou a começar a estudar Android. Neste post, quero apresentar as razões que me levaram a esta escolha. Dentre as inúmeras possibilidades, porque dedicar minhas madrugas a estudar Android? Vamos lá:

1. É Java. Apesar de não ser um expert, na plataforma. Conheço Java o suficiente pra saber lhe dar valor. Não vou entrar nos méritos ou problemas da linguagem, que são amplamente conhecidos, só gostaria de citar dois pontos que a tornam vantajosa com relação às demais. Por ter algum tempo de estrada, encontramos certa facilidade em obter meios de explora-la. Livros, cursos, documentação, tutoriais, até mesmo faculdades com especialização em Java, tornam mais fácil seu aprendizado. Outro ponto forte é sua comunidade de desenvolvedores. Participo de algumas listas de discussões de Java e percebo que há um grande esforço de ajuda mútua entre seus membros. Eventos, palestras, dojos, mini-cursos, competições, etc, são constantemente realizados que todos possam estar em dia com as novidades da plataforma.

2. É um projeto da Google. A gigante da web dispensa apresentações e foi quem desenvolveu inicialmente o Android. É atualmente responsável pela gerência do produto e engenharia de processos. Ter uma grande empresa como a Google desenvolvendo o Android, dá segurança de saber que o projeto é sólido, desenvolvido por uma equipe extremamente qualificada, dando respostas rápidas quando são encontrados bugs, e que o projeto é evoluído constantemente. Atualmente, o projeto é desenvolvido pela Open Handset Alliance (veja item 6).

3. É Free. O código do Android é distribuído sob licença Apache. Ou seja, exige a inclusão do aviso de copyrightdisclaimer, mas não é uma licença copyleft – ela permite o uso e distribuição do código fonte tanto no software open source como no proprietário.

4. Popularização dos smartphones. A venda destes aparelhos tem tido um grande crescimentonos últimos anos e a forte concorrência tem forçado a queda dos preços. O Android tem tido um crescimento fantástico e está prestes a se tornar líder no mercado.

5. A Explosão dos tablets. A corrida para dividir o mercado dos tablets com o iPad da Apple está grande. SamsungDellLGMotorolaAcerASUSHTCToshiba e outras já lançaram, ou estão prestes a fazer seus lançamentos. A espectativa é que o ano de 2011 seja o ano os tablets.

6. A convergência das empresas em direção ao Android. Operadoras de telefonia,fabricantes de celularsemicondutoresempresas de software, criaram uma aliança com a intenção de criar padrões abertos para telefonia móvel, a Open Handset Alliance, encabeçada pela Google.

7. É fácil. arquitetura do Android não tem mistério. As APIs da Google são vastamente documentadas e com pouco esforço já dá pra começar a iteragir com os recursos de hardware. Depois fica por conta da sua dedicação. É preciso também muita criatividade para desenvolver apps atraentes para obter algum retorno ou reconhecimento.

8. O potencial de mercado. Há um grande mercado por ser explorado na área de dispositivos móveis em geral. Além das próprias aplicações nativas dos smartphones, provendo funcionalidades interessantes de uso cotidiano, a integração de sistemas corporativos com a tecnologia móvel me parece ter sido bem pouco explorada. Há também um enorme potencial no Primeiro Setor. Imagine a infinidade de aplicações que as prefeituras podem demandar. Empresas de infraestrutura, setor energético, de abastecimento, logística, etc.

9. É desafiador. A diversidade de recursos dos aparelhos e as possibilidades de serviços que podemos implementar utilizando estes recursos, somados às limitações peculiares a softwares embarcados, formam um cenário desafiador, onde a otimização deve ser o norte.

10. É fácil vender. Crie uma conta na Android Market, publique sua aplicação e terá visibilidade global do seu produto. Eles ficarão com 30% do que você cobrar, mas a vitrine compensa.

Enfim, estou bastante otimista com relação ao potencial que o Android apresenta e resolvi investir nele. Se você enxergou motivos diferentes para aderir ao Android, ou quer questionar os que eu apresentei, comente! Participe! Nos ajude a fortalecer a comunidade de desenvolvimento Android!

 

Fonte: http://mobilein.com.br/?p=386

Instalando OpenJDK no Ubuntu

Posted: January 8, 2011 in Uncategorized

olá Gente,

O post  de hoje, será sobre a instalação e configuração do OpenJDK no Ubuntu, Se vc está começando ou querendo usar o Linux como ambiente de desenvolvimento aproveite o post e veja como é fácil instalar o OpenJDK e ter o Java rodando na sua maquina.Aproveitei!

Vamos que Vamos.

Alguns Requisitos…

Outros posts interessantes

Há vario posts interessantes na categoria Linux.

Instalando Java Ubuntu

Instalando MySQL

Iniciando Instalação

A seguir teremos os passos como instalar. Preste bastante atenção antes de executar, estamos certo que todos os passos descritos aqui atingiremos o objetivo final.

abra o terminal

digite o comando abaixo para instalação do openJDK, você precisa usar o comando sudo

Aperte a tecla enter e responda com y ou deixe em branco apertando enter e aguarde a instalação

Ao termino vamos verificar o java instalado, digitando o comando java -version

Agora vamos fazer, um “Hello World” somente para ter certeza que o Java está compilando nossos arquivos .java. Para isso abra um editor de texto, pode ser o VIM, ou o gedit. Vou usar o gedit que estáApplications ==> Acessories ==> gedit. Abaixo segue meu codigo no gedit:

Feito, isso salve na pasta do usuário, para saber onde está esta pasta basta digitar pwd . Observe que a minha está em /home/meu_nome, a sua deve ser semelhante com o seu nome.

Se você dar o comando ls veremos os arquivos que estão nesta, pasta e um deles é o HelloOpenJDK.javaveja:

Vamos compilar e executar: javac HelloOpenJDK.java e java HelloOpenJDK

Lembre-se que o Linux e case sensitive então ao dar o auto-complete para o arquivo tenha certeza digitou a primeira letra conforme foi salvo.

Se listar verá o .class:

Executando agora:

Agora temos o Java – OpenJDK instalado em um ambiente Ubuntu/Linux.

Vlw!!!

 

 

Fonte: http://blog.camilolopes.com.br/

Bom pessoal, continuando a série de posts sobre Android, hoje explicarei como criar uma pequena aplicação para Android, o famoso “Hello World!”, afinal de contas quem nunca fez um desses…rsrs

Para criar um novo projeto para Android basta seguir o caminho File -> New -> Other. Selecione a opção Android -> Android Project e clique em “Next”. Na próxima tela preencha os campos abaixo, com suas respectivas informações:

Project name: HelloWorld
Application name: Hello World
Package name: br.com.android
Create Activity: AppHelloWorld
Min SDK Version: 9

Após preencher os campos citados anteriormente, selecione o “Target Name” de acordo com versão que você especificou ao criar o AVD que será utilizado nesse projeto. Após realizar essas etapas basta clicar no botão “Finish”.

Pronto!
Seu primeiro projeto para Android está criado.

Para explicar a estrutura de arquivos e diretórios existentes no projeto, utilizarei texto/explicação da apostila “Apostila de Android – Programando Passo a Passo” criada por Luciano Alves, que explica isso de uma forma clara e simples, por isso reproduzirei o excelente texto feito por ele, com as modificações que se fizerem necessárias.

Observem que dentro da pasta “HelloWorld” existe uma pasta chamada “src” e dentro dela é que ficam os códigos fonte java das aplicações. Observem que o arquivo “AppHelloWorld.java” se encontra dentro do pacote “br.com.android” (Esse pacote também é uma pasta). Esse arquivo é a nossa aplicação Android. Vou descrever em detalhes o arquivo “AppHelloWorld.java” (Veja o código abaixo):

package br.com.android;

import android.app.Activity;
import android.os.Bundle;

public class AppHelloWorld extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Diferentemente das aplicações comuns de Java, toda classe para aplicação Android deve ser derivada da classe Activity (Atividade) e possui como método principal, o método onCreate. Dentro desse método ele invoca o método onCreate da super classe passando mesmo parâmetro (o savedInstanceState), logo após esse método, vem o método setContentView, responsável por exibir a tela da minha aplicação , baseado nos layouts xml. Por padrão ele chama o arquivo “main.xml”.

Dentro da pasta “HelloWorldAndroid” existe 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, que descreverei agora:

Diretórios “drawable”

Diferente de algumas versões antigas do Android SDK, como o revision 1, esta versão do SDK trabalha com três diretórios “drawables”, drawable-hdpi,drawable-ldpi, drawable-mdpi.
Todos os três armazenam somente imagens, mas qual a diferença de um para outro? 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 de você estiver usando. Por exemplo, quando você usa uma resolução de 480×800 no seu emulador, é utilizado o diretório “drawable-hdpi” para buscar a imagem que vai representar o ícone da sua aplicação Android.
Se você for usar uma resolução 320×480 (que é a resolução padrão do emulador Android), é utilizado o diretório “drawable-mdpi”. Se você usar uma resolução 240×400, é utilizado o diretório “drawable-ldpi”.

O diretório “layout” armazena todas os layouts da aplicação Android, que normalmente são arquivos “.xml”. Para quem conhece a combinação HTML + JavaScript, o Android é similar, é a combinação de XML + Java, logo todos os nosso componentes vão ser adicionados usando tags XML. Por padrão, o arquivo de layout é o main.xml.
Uma coisa interessante que existe nessa versão (e alguma das anteriores) é a capacidade de você ter um “preview” de como ficara a sua aplicação antes mesmo de você rodar o emulador Android, para confirmarmos isso, simplesmente vá no diretório “res/layout”,e de um duplo clique no arquivo “main.xml”, e você verá o seu preview, conforme demonstra a figura abaixo:


Para visualizarmos o código do arquivo main.xml, simplesmente clique na guia “main.xml”, que se encontra abaixo da seção “Views”.
Observe que após a primeira linha (prólogo xml), existe uma tag chamada LinearLayout, responsável por organizar os componentes exibidos na tela, por padrão os componentes são distribuídos na vertical pelo atributo android:orientation=”vertical”.
Dentro desta tag, existe uma um componente chamado TextView, que representa um texto a ser exibido na tela , por padrão, ele irá exibir “Hello World, AppHelloWorld” através do atributo android:text=”@string/hello”, onde o valor “@string/hello” equivale a uma constante, que está definida no arquivo strings.xml, que se encontra no diretório “values”, que iremos descreve-lo agora.

O diretório “values” armazena valores estáticos que podem ser utilizados por um arquivo “.XML”. Normalmente esses valores estáticos devem ser armazenados no arquivo “strings.xml”. Vá no diretório “res/values” e de um duplo clique no arquivo “strings.xml”, e será mostra o gerenciador desse arquivo.
Observe que nas propriedades do atributo “hello”, está atribuído um valor a ela,que é o valor “Hello World, AppHelloWorld!”, isso quer dizer que lá no arquivo XML, no componente TextView, tem uma propriedade chama “android:text”, com o valor “@string/hello” , que equivale a na verdade a string “Hello World, AppHelloWorld!”. Para ver a sua estrutura , clique na guia “strings.xml”.
Observem que dentro desse arquivo eu declaro um valor estático chamado app_name, cujo valor é “Hello World”.

Dentro da pasta HelloWorld existe um arquivo chamado “AndroidManifest.xml” Esse arquivo é o sistema nervoso de uma aplicação Android. É nele que ficam as definições referentes à aplicação. De um duplo clique nesse arquivo para abri-lo, feito isso será mostrado o seu gerenciador.
Bom, o que nos interessa aqui é o código. Para visualizarmos seu código, clique na seção “AndroidManifest.xml”.
Observem algumas tags interessantes. A tag possui o atributo android:icon, no qual especifico o ícone da aplicação. Como havia citado anteriormente, todas as imagens ficam no diretório drawable e nesse diretório existe um arquivo de chamado “icon.png” que será o ícone da minha aplicação. Logo, para usar esse ícone neste atributo, deve-se passar o valor @drawable/icon .Observem que quando informamos o ícone, ele deve ser informado sem a extensão (nesse caso, PNG).
Observem agora a tag , ela define uma atividade (Activity). Dentro desta tag, eu possuo o atributo chamado android:label que define o título da minha aplicação. O título que será exibido é o valor que está armazenado no valor estático app_name. Isso é obtido pela atribuição android:label=”@string/app_name”.

Como havia falado a aplicação Android nada mais é do que a combinação Java + XML. Agora, como um código Java vai acessar um componente que está escrito em XML ? Ah, essa é a finalidade do arquivo R.java (que fica dentro do pacote “gen” , situado no projeto), ele funciona como uma “interface” entre o código Java e o código XML, logo, se eu quiser manipular em tempo de execução um componente via Java, tenho que fazer interface com esse arquivo. Em breve vamos ver como.
OBS: O arquivo R.java não pode ser modificado manualmente. Ele é modificado automaticamente de acordo com as mudanças feitas no projeto.

Agora iremos executar nossa aplicação. Vamos no menu Run -> Run Configurations. Abrirá uma janela com vários itens. Clique com o botão direito do mouse no item “Android Application” e selecione a opção “New”.
Feito isso, na propriedade “Name” ao lado digite “AppHelloWorld”. Em Project selecione o projeto que criamos clicando no botão “Browse”, com o nome de “HelloWorld”. E por último, em “Launch Action”, deixe marcada a opção “Lauch Default Activity”. Clique em “Apply” e em seguida em “Run”.

Pronto! O emulador começará a ser executado. Isso pode levar alguns minutos na primeira vez.
No início da execução do emulador mostra o título Android depois, vem um outro título escrito “Android”, com um titulo cinza em animação.
Passado essas inicializações, será mostrada a nossa aplicação e também algumas mensagens, é só cancela-las.
A partir daí você pode utilizar o emulador como um smartphone real, ou seja, sair da aplicação, executar outras aplicações e posteriormente voltar a executá-la.

Não feche o emulador, mantenha ele aberto enquanto você estiver desenvolvendo, senão toda vez que você modificar sua aplicação e for rodá-la novamente, você terá que esperar todo aquele tempo que esperou da primeira vez, portanto execute-o e mantenha ele aberto enquanto estiver desenvolvendo, basta realizar suas modificações no aplicativo e executá-lo, dessa forma o eclipse utilizará o emulador aberto, caso contrário ele abrirá um novo e você terá que aguardar todo aquele tempo novamente.

É isso aí pessoal, espero que o post seja útil e qualquer dúvida/problemas é só enviar um comentário que reponderemos em seguida.

 

Promessa feita, promessa cumprida. Rapidamente vamos instalar o ADT no Eclipse tendo como S.O. o Windows.

Não há muita diferença desse post para o anterior para falar a verdade, porém eu preferi dividí-los em dois para que não haja confusão (DUMMIES!!!) e a leitura não fique cansativa demais.

Para mostrar que o blog é imparcial, teremos ao lado também uma imagem motivacional, veja e motive-se.

Mas agora sem brincadeira, fazer o mesmo procedimento no windows, que será mais fácil que no linux.

Chega de falação, mãos à obra.

Eclipse

Podemos instalar o Eclipse fazendo o download em:

http://www.eclipse.org/downloads/

Extraia na sua pasta de preferência e, se quiser, crie um atalho para o Eclipse na área de trabalho. Novamente recomenda-se as versões Java ou RCP.

SDK

Baixemos o SDK no site do android:

http://developer.android.com/sdk/index.html

Extraia o pacote em uma pasta de sua preferência. Agora, vamos atualizar o SDK, você pode fazer isso ou pelo executável SDK Setup na pasta do SDK ou por linha de comando usando:

tools\android.bat update sdk

Se você quiser usar as tools do sdk pela linha de comando, pode adicionar “C:path_para_onde_extraiu_sdkandroid-sdk-windowstools;” ,sem aspas, ao seu path do windows (Editando em : Propriedades do sistema > Avançado > Variáveis de Ambiente > Path) .

Agora teremos que pegar alguma plataforma para compilar o nosso código, então rode o SDK Setup.

Selecione Available Packages no painel a esquerda, selecione os componentes que gostaria de instalar e clique em Install Selected. Você pode instalar todos os componentes ou apenas os que são necessários.

Eu acredito que ninguém esteja economizando Mbs, mas, se quiser instalar só o necessário você precisa apenas de uma Plataforma para compilar( mas para distribuir, escolher qualquer plataforma que quiser não dará certo, baixe a versão 1.5 pelo menos ). Clique em install accepted/install selected.

Dê update nos componentes que desejar e reinicie o Setup.

Daqui pra frente a instalação procede como a do Linux. Vou colocar abaixo para os mais preguiçosos:

ADT Plugin

Abra o seu Eclipse normalmente para instalarmos o ADT plugin, então clique em:
Help > Install New Software > Add
tela1w1 Como começar: instalando ADT no Eclipse (Windows)

Dependendo da sua versão do Eclipse talvez haja um campo nome na nova janela que abriu, invente um, como por exemplo, Android SDK, independente disso, haverá o campo Location e nele você insere:

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

ou caso haja algum problema com “https”

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

Clique em OK e o Eclipse irá procurar a fonte por um tempo, quando aparecer a checkbox Developer Tools, marque-a e clique em Next e novamente Next para instalar.

Se houve algum problema, você ainda pode baixar o ADT:

http://developer.android.com/intl/fr/sdk/eclipse-adt.html

E em vez de adicionar uma url, você adiciona o package que baixou. Clique em OK quando aparecer o aviso de segurança e a instalação irá prosseguir.

Quando for solicitado permita que o sistema reinicie o Eclipse.

Vá em Window > Preferences > Android > Browse > Selecione o path em que você deixou o SDK > Apply > OK

Agora você deve ter algo desse tipo:

tela2w Como começar: instalando ADT no Eclipse (Windows)