Este documento fornece uma introdução detalhada sobre o Android, incluindo:
1) Uma visão geral da plataforma Android, sua estrutura e componentes principais.
2) Instruções passo-a-passo para instalar e configurar o Android SDK no Eclipse para desenvolvimento de aplicativos.
3) Um guia completo sobre como programar aplicativos Android, cobrindo vários widgets, layouts, atividades, menus e mais.
Este livro apresenta o framework Angular 2 utilizando TypeScript, Node, SystemJS e Visual Studio Code. O livro ensina os conceitos básicos de TypeScript como tipos, classes, módulos e decorators, e em seguida cobre a criação de componentes Angular, templates, serviços, formulários e comunicação com servidores.
O documento fornece instruções para desenvolvimento de aplicativos Android, cobrindo tópicos como configuração do ambiente de desenvolvimento, criação de uma aplicação de contatos simples para demonstrar conceitos básicos e adição de recursos avançados como diálogos, internacionalização e preferências do usuário.
1. O documento apresenta um minicurso sobre o software GeoGebra, descrevendo suas ferramentas e funcionalidades para construções geométricas e analise de funções.
2. Inclui instruções sobre a instalação do software, demonstrações de como construir figuras geométricas planas e objetos em 3D, e exemplos de como analisar funções como afins, quadráticas, polinomiais e definidas por partes.
3. Também mostra como utilizar o GeoGebra para calcular derivadas e integrais de funções, demonstrando
Este documento apresenta um tutorial sobre o desenvolvimento de jogos com a engine Unity 3D. Ele discute a interface do editor de cenas da Unity 3D e fornece uma introdução sobre a criação e manipulação de objetos de jogo, materiais, sistema de física e programação com scripts. O tutorial é destinado a desenvolvedores com experiência prévia em conceitos de jogos 3D.
O documento descreve a introdução ao sistema operacional OpenSolaris, incluindo seu histórico, vantagens, instalação em máquina virtual e computador, configuração de rede, idioma e drivers, e uso das interfaces gráfica e de texto. É compilado a partir de diversos materiais livres e licenciado sob a GNU Free Documentation License.
Este documento fornece informações sobre como usar o sistema operacional Ubuntu recém-instalado, incluindo explicações sobre termos comuns, atualizações, aplicativos pré-instalados e dicas úteis.
Tcc - Desenvolvimento de jogos eletrônicos utilizando a tecnologia Unity - Lu...Luis Henrique Ferreira
TCC - Trabalho de Desenvolvimento de jogos eletrônicos utilizando a tecnologia Unity, Maya, MudBox, FL Studio e Photoshop - Trabalho de Conclusão de Curso (TCC) apresentado ao Departamento de Ciências da Administração e Tecnologia, do Centro Universitário de Araraquara - UNIARA, como parte dos requisitos para obtenção do título de Bacharel em Sistemas de Informação
Este livro apresenta o framework Angular 2 utilizando TypeScript, Node, SystemJS e Visual Studio Code. O livro ensina os conceitos básicos de TypeScript como tipos, classes, módulos e decorators, e em seguida cobre a criação de componentes Angular, templates, serviços, formulários e comunicação com servidores.
O documento fornece instruções para desenvolvimento de aplicativos Android, cobrindo tópicos como configuração do ambiente de desenvolvimento, criação de uma aplicação de contatos simples para demonstrar conceitos básicos e adição de recursos avançados como diálogos, internacionalização e preferências do usuário.
1. O documento apresenta um minicurso sobre o software GeoGebra, descrevendo suas ferramentas e funcionalidades para construções geométricas e analise de funções.
2. Inclui instruções sobre a instalação do software, demonstrações de como construir figuras geométricas planas e objetos em 3D, e exemplos de como analisar funções como afins, quadráticas, polinomiais e definidas por partes.
3. Também mostra como utilizar o GeoGebra para calcular derivadas e integrais de funções, demonstrando
Este documento apresenta um tutorial sobre o desenvolvimento de jogos com a engine Unity 3D. Ele discute a interface do editor de cenas da Unity 3D e fornece uma introdução sobre a criação e manipulação de objetos de jogo, materiais, sistema de física e programação com scripts. O tutorial é destinado a desenvolvedores com experiência prévia em conceitos de jogos 3D.
O documento descreve a introdução ao sistema operacional OpenSolaris, incluindo seu histórico, vantagens, instalação em máquina virtual e computador, configuração de rede, idioma e drivers, e uso das interfaces gráfica e de texto. É compilado a partir de diversos materiais livres e licenciado sob a GNU Free Documentation License.
Este documento fornece informações sobre como usar o sistema operacional Ubuntu recém-instalado, incluindo explicações sobre termos comuns, atualizações, aplicativos pré-instalados e dicas úteis.
Tcc - Desenvolvimento de jogos eletrônicos utilizando a tecnologia Unity - Lu...Luis Henrique Ferreira
TCC - Trabalho de Desenvolvimento de jogos eletrônicos utilizando a tecnologia Unity, Maya, MudBox, FL Studio e Photoshop - Trabalho de Conclusão de Curso (TCC) apresentado ao Departamento de Ciências da Administração e Tecnologia, do Centro Universitário de Araraquara - UNIARA, como parte dos requisitos para obtenção do título de Bacharel em Sistemas de Informação
Este documento fornece informações sobre direitos autorais e marcas registradas relacionadas ao software Adobe Photoshop. Ele descreve que o conteúdo do guia está protegido por direitos autorais e não pode ser copiado ou distribuído sem permissão. Também lista várias marcas registradas pertencentes à Adobe e outras empresas.
Este documento fornece um resumo das principais funções do software DutotecCAD para projetos de cabeamento. O software acrescenta ferramentas ao AutoCAD que facilitam a realização de projetos de cabeamento, sem interferir nas demais funções do AutoCAD. O DutotecCAD é apresentado na forma de uma barra de ferramentas agrupada por etapas do projeto: Sistema, Lançamento, Cálculo e Detalhe. As ferramentas permitem inserir, conectar e especificar elementos como dutos, racks, quadros e pontos
O documento fornece um guia de utilização do Adobe Fireworks CS5, descrevendo suas principais funcionalidades e como utilizá-las. É dividido em capítulos que cobrem novos recursos, conceitos básicos, a área de trabalho, seleção e edição de objetos.
Este documento fornece um guia sobre o ActionScript para o Flash 5, abordando:
- Novas funcionalidades do ActionScript no Flash 5 como suporte a XML, clipes inteligentes e depurador aprimorado.
- Sintaxe básica, tipos de dados, variáveis, operadores, fluxo de scripts, funções e objetos.
- Como criar interatividade com scripts manipulando cursor, teclas, som, detecção de colisão.
- Controle de vários clipes de filme e caminhos de destino.
- Integração com a
1) O documento contém instruções de segurança e direitos autorais para o projetor PowerLite S5 Series/77c.
2) Inclui advertências sobre não olhar diretamente na lâmpada acesa, manter embalagens plásticas longe de crianças, e não tocar diretamente na lâmpada nova.
3) Detalha que todos os direitos estão reservados e nenhuma parte da publicação pode ser reproduzida sem permissão por escrito da Seiko Epson Corporation.
1. Este guia fornece informações sobre aprendizado, operação e configuração de sistemas Linux.
2. Novas versões são lançadas mensalmente e os usuários podem se inscrever para receber notificações.
3. O guia está sob a licença GNU Free Documentation License.
Este documento apresenta um plano de ensino para programação C++, cobrindo tópicos como introdução à linguagem, tipos de dados, operadores, estruturas de controle, vetores, ponteiros, programação orientada a objetos, templates e namespaces.
Este relatório descreve o desenvolvimento de um jogo para Android chamado "Blinded Walker". O jogo envolve um personagem que deve navegar por níveis evitando obstáculos enquanto é guiado por sons. O relatório detalha os desafios técnicos enfrentados como renderização gráfica, animação, entrada do usuário, colisão e áudio. O projeto fornece soluções para problemas comuns no desenvolvimento de jogos para Android.
Este documento fornece informações sobre o software Blender, incluindo:
1) Uma introdução ao Blender, sua história e visão geral;
2) Instruções para instalação do Blender;
3) Uma explicação da interface do usuário do Blender;
4) Diretrizes para manipulação e modelagem de objetos no Blender.
Este guia fornece instruções sobre como usar o Windows Movie Maker. Ele explica como executar tarefas como gravar material de origem, importar arquivos, editar projetos, adicionar transições, trabalhar com áudio, visualizar projetos e enviar filmes. O guia também descreve os principais componentes da interface do usuário do Windows Movie Maker e fornece dicas sobre teclas de atalho e solução de problemas.
Este manual fornece instruções sobre como usar o editor Kate, incluindo como iniciar, navegar na interface, usar plugins e ferramentas, personalizar configurações e estender suas funcionalidades. O manual também lista as opções de menu e fornece detalhes sobre recursos avançados.
Este documento fornece instruções sobre como aprender ActionScript 2.0 no Flash. Ele inclui uma lista de marcas comerciais e tecnologias licenciadas, informações sobre direitos autorais e uma lista de agradecimentos.
Este documento fornece instruções sobre como usar o Adobe Flash Professional CS5. Explica os novos recursos, o espaço de trabalho, como gerenciar documentos, importar arte e usar ferramentas. Também inclui informações legais e de direitos autorais.
O documento apresenta um curso sobre desenvolvimento mobile com Android. O curso aborda tópicos como introdução à plataforma Android, criação de aplicativos, layouts, uso de intents, persistência de dados, HTTP e JSON, threads e serviços. O curso é composto por 10 módulos que ensinam sobre essas temáticas e incluem exercícios de fixação.
Este documento descreve os termos de uso de uma obra. De acordo com a licença, os leitores podem copiar, exibir e executar a obra, desde que deem crédito ao autor original. Não é permitida a criação de obras derivadas ou o uso comercial da obra. As condições da licença podem ser modificadas com a permissão do autor.
Este documento fornece instruções para instalar o sistema operacional Debian GNU/Linux 3.1 na arquitetura Intel x86. Ele discute os requisitos de hardware, etapas pré-instalação e configurações necessárias no BIOS. O documento também contém informações sobre direitos autorais e licenciamento do software.
1) Este documento discute a linguagem de programação ActionScript 3.0, incluindo suas vantagens em relação às versões anteriores e novos recursos como melhor desempenho, modelo orientado a objetos aprimorado e suporte a XML.
2) Os capítulos cobrem tópicos como introdução ao ActionScript, programação básica, orientação a objetos, classes, interfaces, herança e exemplos de código.
3) O ActionScript 3.0 permite maior interatividade e manipulação de dados em conteúdo Flash, Flex e A
Este documento é um prefácio para um guia do Ubuntu escrito por Carlos Eduardo do Val. O prefácio discute como o guia visa ajudar usuários iniciantes a se familiarizarem com o Ubuntu de uma maneira fácil e acessível, ao invés de focar em conceitos técnicos complexos. O autor do prefácio elogia os esforços do guia para desmistificar o Ubuntu e torná-lo acessível para diferentes públicos, inclusive aqueles que não possuem conhecimento técnico avançado.
O documento fornece 10 dicas para profissionais de front-end melhorarem o posicionamento de sites nos mecanismos de busca, especialmente no Google, através de otimizações relacionadas a SEO. As dicas incluem configurar ferramentas do Google e Bing para webmasters, melhorar títulos, imagens, URLs, tempo de carregamento, usar marcações rich snippets, sitemaps XML e lidar com conteúdo AJAX e Flash.
O documento discute práticas ágeis como desenvolvimento orientado a testes, testes unitários, TDD, BDD, programação em par, integração contínua e testes de aceitação. O foco é na realização de testes automatizados em todas as etapas do desenvolvimento de software.
O documento discute a criação de jogos 2D usando a linguagem de programação Lua e as ferramentas Love2D e Corona SDK. Ele fornece uma introdução a Lua, incluindo suas origens, características e tipos de dados, e explica como Love2D e Corona SDK podem ser usados para desenvolver jogos 2D multiplataforma em Lua. O documento também discute considerações iniciais para começar um novo projeto de jogo e recursos recomendados para aprender mais sobre desenvolvimento de jogos com Lua.
Descrição:
Apresentação utilizada para o seminário: Vídeo Games. Esta apresentação contém informações sobre a história do vídeo game, conceitos e suas convergências
----
Instituição: Centro Universitário Senac
Curso: Publicidade e Propaganda
Disciplina: História da Publicidade e Propaganda
Período: 1ºSEM/2012
Este documento fornece informações sobre direitos autorais e marcas registradas relacionadas ao software Adobe Photoshop. Ele descreve que o conteúdo do guia está protegido por direitos autorais e não pode ser copiado ou distribuído sem permissão. Também lista várias marcas registradas pertencentes à Adobe e outras empresas.
Este documento fornece um resumo das principais funções do software DutotecCAD para projetos de cabeamento. O software acrescenta ferramentas ao AutoCAD que facilitam a realização de projetos de cabeamento, sem interferir nas demais funções do AutoCAD. O DutotecCAD é apresentado na forma de uma barra de ferramentas agrupada por etapas do projeto: Sistema, Lançamento, Cálculo e Detalhe. As ferramentas permitem inserir, conectar e especificar elementos como dutos, racks, quadros e pontos
O documento fornece um guia de utilização do Adobe Fireworks CS5, descrevendo suas principais funcionalidades e como utilizá-las. É dividido em capítulos que cobrem novos recursos, conceitos básicos, a área de trabalho, seleção e edição de objetos.
Este documento fornece um guia sobre o ActionScript para o Flash 5, abordando:
- Novas funcionalidades do ActionScript no Flash 5 como suporte a XML, clipes inteligentes e depurador aprimorado.
- Sintaxe básica, tipos de dados, variáveis, operadores, fluxo de scripts, funções e objetos.
- Como criar interatividade com scripts manipulando cursor, teclas, som, detecção de colisão.
- Controle de vários clipes de filme e caminhos de destino.
- Integração com a
1) O documento contém instruções de segurança e direitos autorais para o projetor PowerLite S5 Series/77c.
2) Inclui advertências sobre não olhar diretamente na lâmpada acesa, manter embalagens plásticas longe de crianças, e não tocar diretamente na lâmpada nova.
3) Detalha que todos os direitos estão reservados e nenhuma parte da publicação pode ser reproduzida sem permissão por escrito da Seiko Epson Corporation.
1. Este guia fornece informações sobre aprendizado, operação e configuração de sistemas Linux.
2. Novas versões são lançadas mensalmente e os usuários podem se inscrever para receber notificações.
3. O guia está sob a licença GNU Free Documentation License.
Este documento apresenta um plano de ensino para programação C++, cobrindo tópicos como introdução à linguagem, tipos de dados, operadores, estruturas de controle, vetores, ponteiros, programação orientada a objetos, templates e namespaces.
Este relatório descreve o desenvolvimento de um jogo para Android chamado "Blinded Walker". O jogo envolve um personagem que deve navegar por níveis evitando obstáculos enquanto é guiado por sons. O relatório detalha os desafios técnicos enfrentados como renderização gráfica, animação, entrada do usuário, colisão e áudio. O projeto fornece soluções para problemas comuns no desenvolvimento de jogos para Android.
Este documento fornece informações sobre o software Blender, incluindo:
1) Uma introdução ao Blender, sua história e visão geral;
2) Instruções para instalação do Blender;
3) Uma explicação da interface do usuário do Blender;
4) Diretrizes para manipulação e modelagem de objetos no Blender.
Este guia fornece instruções sobre como usar o Windows Movie Maker. Ele explica como executar tarefas como gravar material de origem, importar arquivos, editar projetos, adicionar transições, trabalhar com áudio, visualizar projetos e enviar filmes. O guia também descreve os principais componentes da interface do usuário do Windows Movie Maker e fornece dicas sobre teclas de atalho e solução de problemas.
Este manual fornece instruções sobre como usar o editor Kate, incluindo como iniciar, navegar na interface, usar plugins e ferramentas, personalizar configurações e estender suas funcionalidades. O manual também lista as opções de menu e fornece detalhes sobre recursos avançados.
Este documento fornece instruções sobre como aprender ActionScript 2.0 no Flash. Ele inclui uma lista de marcas comerciais e tecnologias licenciadas, informações sobre direitos autorais e uma lista de agradecimentos.
Este documento fornece instruções sobre como usar o Adobe Flash Professional CS5. Explica os novos recursos, o espaço de trabalho, como gerenciar documentos, importar arte e usar ferramentas. Também inclui informações legais e de direitos autorais.
O documento apresenta um curso sobre desenvolvimento mobile com Android. O curso aborda tópicos como introdução à plataforma Android, criação de aplicativos, layouts, uso de intents, persistência de dados, HTTP e JSON, threads e serviços. O curso é composto por 10 módulos que ensinam sobre essas temáticas e incluem exercícios de fixação.
Este documento descreve os termos de uso de uma obra. De acordo com a licença, os leitores podem copiar, exibir e executar a obra, desde que deem crédito ao autor original. Não é permitida a criação de obras derivadas ou o uso comercial da obra. As condições da licença podem ser modificadas com a permissão do autor.
Este documento fornece instruções para instalar o sistema operacional Debian GNU/Linux 3.1 na arquitetura Intel x86. Ele discute os requisitos de hardware, etapas pré-instalação e configurações necessárias no BIOS. O documento também contém informações sobre direitos autorais e licenciamento do software.
1) Este documento discute a linguagem de programação ActionScript 3.0, incluindo suas vantagens em relação às versões anteriores e novos recursos como melhor desempenho, modelo orientado a objetos aprimorado e suporte a XML.
2) Os capítulos cobrem tópicos como introdução ao ActionScript, programação básica, orientação a objetos, classes, interfaces, herança e exemplos de código.
3) O ActionScript 3.0 permite maior interatividade e manipulação de dados em conteúdo Flash, Flex e A
Este documento é um prefácio para um guia do Ubuntu escrito por Carlos Eduardo do Val. O prefácio discute como o guia visa ajudar usuários iniciantes a se familiarizarem com o Ubuntu de uma maneira fácil e acessível, ao invés de focar em conceitos técnicos complexos. O autor do prefácio elogia os esforços do guia para desmistificar o Ubuntu e torná-lo acessível para diferentes públicos, inclusive aqueles que não possuem conhecimento técnico avançado.
O documento fornece 10 dicas para profissionais de front-end melhorarem o posicionamento de sites nos mecanismos de busca, especialmente no Google, através de otimizações relacionadas a SEO. As dicas incluem configurar ferramentas do Google e Bing para webmasters, melhorar títulos, imagens, URLs, tempo de carregamento, usar marcações rich snippets, sitemaps XML e lidar com conteúdo AJAX e Flash.
O documento discute práticas ágeis como desenvolvimento orientado a testes, testes unitários, TDD, BDD, programação em par, integração contínua e testes de aceitação. O foco é na realização de testes automatizados em todas as etapas do desenvolvimento de software.
O documento discute a criação de jogos 2D usando a linguagem de programação Lua e as ferramentas Love2D e Corona SDK. Ele fornece uma introdução a Lua, incluindo suas origens, características e tipos de dados, e explica como Love2D e Corona SDK podem ser usados para desenvolver jogos 2D multiplataforma em Lua. O documento também discute considerações iniciais para começar um novo projeto de jogo e recursos recomendados para aprender mais sobre desenvolvimento de jogos com Lua.
Descrição:
Apresentação utilizada para o seminário: Vídeo Games. Esta apresentação contém informações sobre a história do vídeo game, conceitos e suas convergências
----
Instituição: Centro Universitário Senac
Curso: Publicidade e Propaganda
Disciplina: História da Publicidade e Propaganda
Período: 1ºSEM/2012
O documento discute PyGame, uma biblioteca Python para desenvolvimento de jogos e aplicações multimídia. Apresenta as vantagens e desvantagens de PyGame, eventos essenciais como Surface e Display, técnicas de detecção de colisão e exemplos de jogos feitos com PyGame como Legacy of Magic. Fornece também fontes para estudar mais sobre a biblioteca.
Gamificação na Computação - Campus Party Brasil 2017Sandy Maciel
Temos a necessidade de motivar o time de trabalho de forma que sejam sempre comprometidos e estejam em alta performance. Gamificação é uma técnica que utiliza estratégias de jogos para engajar pessoas em torno de objetivos em comum, tendo como estímulo premiações. Esta técnica vem sendo adotada em vários seguimentos como educação, marketing, esportes e etc. Desse modo, nessa atividade, será exibido como a gamificação pode tornar o processo de desenvolvimento mais eficaz e ainda manter o time engajado e comprometido.
Clojure é uma linguagem de programação funcional e dinâmica executada na JVM, desenvolvida por Rich Hickey como uma variante moderna de Lisp. É caracterizada pelo desenvolvimento dinâmico, programação funcional, herança de recursos de Lisp e polimorfismo em tempo de execução.
Introdução a testes de software utilizando seleniumSandy Maciel
O documento apresenta uma introdução sobre teste de software utilizando Selenium. Apresenta as palestrantes Debora Queiroz e Sandy Maciel, suas experiências na área de teste e qualidade. Em seguida, descreve o roteiro da apresentação, incluindo definições de qualidade de software, teste de software, testes manuais versus automatizados e como desenvolver testes automatizados utilizando a ferramenta Selenium.
O documento discute padrões de projeto de software, incluindo padrões de criação, estruturais e comportamentais. Também apresenta um padrão de projeto chamado "Page Object" para organizar testes funcionais de páginas web usando orientação a objetos.
Noções em teste de software e introdução a automaçãoSandy Maciel
O documento apresenta conceitos básicos de teste de software, incluindo princípios, papéis, ciclo de vida de desenvolvimento e tipos de testes. Também fornece uma introdução ao Selenium WebDriver, abordando automação de testes e preparação do ambiente.
User Experience (UX) refere-se à faculdade perceptiva e respostas de um indivíduo ao utilizar ou antecipar a utilização de um produto, sistema ou serviço. Embora relacionada, UX é diferente de usabilidade, que se refere à medida em que um sistema pode ser utilizado para atingir objetivos de forma eficaz e satisfatória. UX envolve fatores como utilidade, usabilidade e desejabilidade de um sistema para o usuário.
O documento fornece 10 dicas para profissionais de front-end melhorarem o SEO de seus sites, incluindo usar as ferramentas do Google e Bing para webmasters, otimizar títulos, imagens, URLs, tempo de carregamento, e implementar recursos como rich snippets, sitemaps e técnicas para lidar com AJAX e Flash.
O documento discute testes de desempenho (carga/stress) e suas principais ferramentas. Ele define testes de desempenho, carga e stress, explica porque eles são importantes, e discute tipos de testes de carga e stress, o processo de teste de desempenho e ferramentas populares como JMeter, Tsung e Siege.
O documento apresenta um resumo sobre orientação a objetos em PHP, abordando tópicos como: classes, atributos, métodos, encapsulamento, herança, instanciação de objetos, conversão para string e referência vs clonagem.
O documento descreve a ferramenta Trello para gerenciamento de projetos, incluindo boards, listas, cartões e recursos. Boards representam projetos, listas são estágios das tarefas, e cartões são as tarefas individuais. A ferramenta permite organizar projetos, acompanhar status de tarefas, e colaborar em um board com membros.
O documento apresenta 11 dicas de crescimento ("growth hacks") para aquisição de tráfego e clientes, incluindo o uso de landing pages, testes A/B, ferramentas para criação de landing pages, pesquisa de termos-chave, descoberta de ideias de conteúdo, criação de conteúdo com base no feedback do público, reotimização de conteúdo, análise da concorrência, elementos essenciais de SEO, vídeos no Facebook e monitoramento de emails de concorrentes.
Iniciando o Desenvolvimento para o Google AndroidSalvador Torres
O documento discute a plataforma Android, incluindo seu crescimento no mercado móvel, arquitetura baseada em Java e Linux, e ferramentas de desenvolvimento. A Open Handset Alliance visa padronizar a plataforma para atender as expectativas do mercado. O Android permite customização por meio de aplicativos e integração com recursos nativos dos dispositivos.
Este documento fornece uma introdução sobre o que é desenvolvimento front-end, incluindo as principais tecnologias (HTML, CSS e JavaScript), boas práticas de organização de código e projetos, ferramentas, e como se manter atualizado na área.
Desenvolvimento de Apps e Games para Android - Parte 1Erisvaldo Junior
O documento discute a arquitetura do Android, mercados de aplicativos móveis e o futuro da plataforma Android. Ele descreve os principais componentes da arquitetura do Android, como Applications, Application Framework, Libraries e Android Runtime. Também discute as principais versões do Android lançadas e novas funcionalidades como NFC, Google Wallet e Google TV.
Este documento fornece uma introdução à programação para a plataforma Android usando o Eclipse. Ele explica a estrutura do Android, como instalar o Eclipse e o SDK do Android, e ensina como criar aplicativos simples usando widgets comuns.
Adicionar mais informações (descrição, tags, categoria) torna mais fácil para os outros encontrar seu conteúdo. A pontuação aumenta conforme você adiciona cada item.
Este documento descreve os fundamentos da programação orientada a objetos utilizando a linguagem Java. Ele discute conceitos como classes, objetos, herança e polimorfismo e apresenta os principais elementos da linguagem Java como tipos, expressões, classes, exceções e APIs.
Este documento fornece informações sobre o Zope, incluindo o que é Zope, como instalá-lo e usar sua interface de gerenciamento, trabalhar com objetos, DTML, modelos de páginas, aplicações básicas, segurança de usuários, catálogos de pesquisa e bancos de dados, e extensões do Zope.
Este documento fornece uma introdução ao Javascript, incluindo seu objetivo, público-alvo, pré-requisitos, descrição, metodologia e cronograma de ensino. Ele também discute tópicos-chave como sintaxe, variáveis, strings, objetos, arrays, operadores, funções e classes.
Este documento fornece instruções sobre como instalar e configurar o sistema operacional OpenSolaris, incluindo baixar e usar uma máquina virtual, instalação no computador, configuração de rede, idioma e instalação de programas adicionais. Ele também explica como usar a interface gráfica GNOME e realizar operações no modo de texto, além de instalar o pacote de escritório OpenOffice.
O documento discute o Java Database Connectivity (JDBC), incluindo sua instalação e conceitos básicos e avançados. Ele fornece detalhes sobre como conectar e interagir com bancos de dados relacionais usando JDBC, incluindo a criação e manipulação de tabelas, inserção, atualização e recuperação de dados, e o uso de transações.
1) O documento descreve uma dissertação de mestrado sobre o desenvolvimento de um framework para interfaces multimodais em aplicações de computação ubíqua, integrando escrita e voz.
2) Foi construído um framework chamado JMIS que integra as modalidades de escrita e voz usando técnicas como integração baseada em unificação e gramáticas multimodais baseadas em unificação.
3) Duas aplicações foram construídas usando o framework - SpeechBoard e M4Note - demonstrando sua funcionalidade para fusão de modalidades.
Este documento apresenta um plano de ensino sobre JSP e Servlets. O documento discute o que são JSP e Servlets, apresenta o objetivo, público-alvo e pré-requisitos do curso, além de detalhar o cronograma e programa do curso. O documento também fornece instruções sobre instalação e configuração do ambiente de desenvolvimento, e aborda conceitos importantes como orientação a objetos, tags JSP, JSTL, ciclo de vida de servlets e tratamento de erros.
Este documento fornece uma introdução ao curso de Acessibilidade para WebDesigners, descrevendo seu objetivo, público-alvo, pré-requisitos, programa, metodologia, avaliação e bibliografia. Ele também apresenta técnicas e diretrizes para projetar sites acessíveis de acordo com padrões internacionais, além de discutir a importância da acessibilidade e inclusão digital.
Este documento descreve um projeto desenvolvido para a disciplina de Projeto na Universidade da Beira Interior. O objetivo do projeto foi construir uma plataforma que permitisse melhorar a experiência de utilização dos transportes públicos através da computação ubíqua. A equipa desenvolveu uma arquitetura complexa que inclui um servidor, aplicações móveis e clientes Windows para fornecer informações aos utilizadores. O relatório detalha o trabalho realizado em cada componente para alcançar este objetivo.
Este documento fornece uma introdução básica sobre informática. Resume os principais tópicos sobre software, sistemas operacionais, hardware, internet, e-mail, Microsoft Word e segurança na internet.
O documento introduz a linguagem C, abordando conceitos como tipos de variáveis, memória, ponteiros, manipulação de arquivos e strings. O autor pretende desmistificar assuntos complexos da linguagem e fornecer exemplos práticos para o desenvolvimento de aplicações.
O documento introduz a linguagem C, abordando conceitos como tipos de variáveis, memória, ponteiros, manipulação de arquivos e strings. O autor pretende desmistificar assuntos complexos da linguagem e fornecer exemplos práticos para o desenvolvimento de aplicações.
K19 k41 Desenvolvimento Mobile com AndroidAline Diniz
A K19 é uma empresa especializada na capacitação de desenvolvedores de software. Sua equipe
é composta por profissionais formados em Ciência da Computação pela Universidade de São Paulo
(USP) e que possuem vasta experiência em treinamento de profissionais para área de TI.
O principal objetivo da K19 é oferecer treinamentos de máxima qualidade que relacionados às
principais tecnologias utilizadas pelas empresas. Através desses treinamentos, seus alunos se tornam
capacitados para atuar no mercado de trabalho.
Visando a máxima qualidade, a K19 mantém as suas apostilas em constante renovação e melhoria,
oferece instalações físicas apropriadas para o ensino e seus instrutores estão sempre atualizados
didática e tecnicamente. Uma das vantagens de desenvolver para o Android é que as ferramentas e programas necessários
são todos gratuitos e disponíveis para todos os sistemas operacionais (OS X,Windows™e Linux).
Para começar a programar para o Android é necessário conhecer (ou aprender) a linguagem Java,
pois foi a linguagem escolhida pela Google.
1. Scilab is a software environment for numerical computation and control system design.
2. It was created by researchers in France and is now maintained by a consortium of French companies and institutions.
3. The document provides an introduction to using Scilab, including its graphical interface, variables, file handling, help system, programming commands, and plotting capabilities.
1. Scilab is a software environment for numerical computation and control system design.
2. It was created by researchers in France and is now maintained by a consortium.
3. The document provides an introduction to using Scilab, including its graphical interface, variables, file handling, help system, and writing Scilab scripts.
Este documento é uma apostila sobre conceitos básicos da linguagem C# para programação .NET. A apostila introduz os principais tópicos como a plataforma .NET, a estrutura de um programa C#, variáveis, comandos, operadores, programação orientada a objetos, tratamento de erros, manipulação de arquivos e conexão com banco de dados. O documento é dividido em 12 seções principais cobrindo esses assuntos fundamentais da linguagem C#.
Este documento apresenta uma introdução à linguagem de programação Python, incluindo tópicos como instalação, ambientes de desenvolvimento, modo interativo, tipos de dados, instruções de controle de fluxo, estruturação de código, entrada/saída, biblioteca padrão e aplicações ao cálculo numérico.
Dissertação de Mestrado - Planejamento para Serviços Web SemânticosJuliana Chahoud
Planejamento para serviços Web semânticos
Juliana Jabra Chahoud
DISSERTAÇÃO APRESENTADA AO
INSTITUTO DE MATEMATICA E ESTATISTICA
DA UNIVERSIDADE DE SAO PAULO
PARA OBTENÇÃO DO TÍTULO DE MESTRE EM CÊNCIAS
Área de Concentração: Ciência da Computação
Orientadora: Profa. Dra. Leliane Nunes de Barros
São Paulo, agosto de 2006.
Dissertação de Mestrado - Planejamento para Serviços Web Semânticos
android
1. Luciano Alves da Silva
Apresentação
O
Android é uma plataforma aberta voltada para
dispositivos móveis desenvolvida pela Google e
atualmente é mantida pela Open Handset Alliance
(OHA). Todas as aplicações desenvolvidas para essa plataforma
utilizam a linguagem Java, o que facilita muitos programadores
com conhecimentos em Java a desenvolver aplicações para essa
plataforma.
Este livro tem por objetivo mostrar de modo fácil como
programar na plataforma para dispositivos móveis da Google
(Android) usando a IDE Eclipse.
Para quem dedico este livro?
Este livro é dedicado aos usuários experientes ou iniciantes em
programação (tanto para Desktop, Móbile e etc.), que já tenha
algum contato com a linguagem Java ou de suas derivadas (C,
C++ ou C#).
2. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Índice analítico
1) Visão geral sobre o Google Android ................................... 6
1.1) Introdução...................................................................... 6
1.2) Estrutura Geral da plataforma Google Android ............ 9
1.2.1) A arquitetura do Android.......................................... 10
1.2.2) Aplicações ................................................................ 10
1.2.3) Android Runtime ...................................................... 12
1.2.4) Linux Kernel............................................................. 12
2) Instalando e Configurando o Android SDK no Eclipse .. 13
3) Começando a programar no Google Android ................. 31
4) Conhecendo as widgets do Android.................................. 52
4.1) A widget TextView ..................................................... 52
4.2) A widget EditText ....................................................... 52
4.3) A widget Button .......................................................... 52
4.4) Desenvolvendo uma aplicação que soma números ..... 52
4.5) A widget AutoCompleteTextView.............................. 69
4.6) A widget CheckBox .................................................... 74
4.7) Desenvolvendo uma aplicação simples de compras.... 74
4.8) A widget RadioButton ................................................. 80
4.9) Desenvolvendo uma aplicação de cálculo de salário
(Com RadioButton)................................................................... 80
4.10) A widget Spinner ....................................................... 90
4.11) Desenvolvendo uma aplicação de cálculo de salário
(Com Spinner)........................................................................... 91
4.12) A widget ListView .................................................... 97
4.13) Desenvolvendo uma aplicação de lista telefônica ..... 97
4.14) A widget Imageview................................................ 103
2
3. Luciano Alves da Silva
4.15) Desenvolvendo uma aplicação que visualiza imagens
(Com ImageView) .................................................................. 103
4.16) A widget Gallery ..................................................... 114
4.17) Desenvolvendo uma aplicação que visualiza imagens
(Com Gallery) ......................................................................... 114
4.18) A widget ProgressBar.............................................. 125
4.19) Desenvolvendo uma aplicação que simula um
download................................................................................. 126
4.20) A widget SeekBar.................................................... 133
4.21) Desenvolvendo uma aplicação que demonstre o
sistema RGB Color. ................................................................ 133
4.22) A widget DatePicker................................................ 141
4.23) Desenvolvendo uma aplicação de calendário.......... 141
4.24) A widget TimePicker............................................... 145
4.25) Desenvolvendo uma aplicação que faz uso do
TimePicker.............................................................................. 145
4.26) A widget ToogleButton ........................................... 149
4.27) Desenvolvendo uma aplicação que faz uso do
ToogleButton .......................................................................... 149
4.28) A widget Chronometer ............................................ 152
4.29) Desenvolvendo um cronômetro digital ................... 152
4.30) A widget DigitalClock............................................. 161
4.31) Desenvolvendo uma aplicação que mostra a hora
corrente do sistema. ................................................................ 161
4.32) A widget ZoomControls .......................................... 163
4.33) Desenvolvendo um programa que aplica zoom em
Imagens ................................................................................... 163
5) Mudando de layouts ......................................................... 170
5.1) Desenvolvendo uma aplicação de cadastro ............... 177
6) Trabalhando com mais de uma Activity (Atividade) .... 203
3
4. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
7) Trabalhando com o componente TabWidget................. 210
8) Trabalhando com menus em uma aplicação.................. 219
9 ) Conhecendo as caixas de diálogo do Android............... 229
9.1) A classe AlertDialog.................................................. 229
9.2) A classe DatePickerDialog ........................................ 237
9.3) A classe TimePickerDialog ....................................... 239
9.4) A classe ProgressDialog ............................................ 241
9.5) Criando uma caixa de diálogo personalizada ........... 245
10) Programação com internet em Android....................... 248
10.1) Trabalhando com sockets em Android .................... 248
10.2) Desenvolvendo uma aplicação cliente em Android e
um servidor Java. .................................................................... 249
10.3) Obtendo conteúdo de uma URL .............................. 263
10.4) Enviando informações para uma página Web via URL
................................................................................................ 269
10.5) Enviando informações para uma página Web via
POST (Usando a classe HttpPost) .......................................... 275
10.6) Fazendo download de um arquivo........................... 285
10.7) O componente WebView ........................................ 289
10.8) Desenvolvendo uma aplicação que visita páginas Web
................................................................................................ 292
11) Programação com multimídia ....................................... 296
12) Programação com banco de dados................................ 330
12.1) A linguagem SQL.................................................... 330
12.1.1) O comando CREATE TABLE ............................. 331
12.1.2) O comando INSERT............................................. 332
12.1.3) O comando UPDATE........................................... 332
4
6. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
1) Visão geral sobre o Google Android
1.1) Introdução
C
onforme mencionado na apresentação deste livro, o
Android é uma plataforma desenvolvida pela Google
voltada para dispositivos móveis, totalmente aberta é
livre (Open Source), que foi divulgada em 5 de novembro de
2007. Ela foi desenvolvida na plataforma Java com sistema
operacional Linux e atualmente essa plataforma é mantida pela
OHA (Open Handset Alliance), um grupo constituído por
aproximadamente 80 empresas as quais se uniram para inovar
e acelerar o desenvolvimento de aplicações e serviços, com o
objetivo e trazer aos consumidores uma experiência mais rica
em termos de recursos, menos dispendiosa em ternos financeiros
para o mercado móvel.
Um dos SmartPhones que ofereceu suporte a esse sistema
operacional foi o G1 da empresa T-Mobile. Confira na imagem
seguinte:
6
7. Luciano Alves da Silva
G1 - T-Mobile
Não demorou muito para que o Android chegasse aqui no
Brasil. Hoje já contamos com operadoras como a Claro, TIM e
Vivo que já oferecem suporte a essa plataforma.
Os SmartPhones disponíveis aqui no Brasil oferecidos por
algumas dessas operadoras, que suportam o sistema Android é
o Samgung Galaxy e o Motorola Milestone. Confira esses
SmartPhones nas imagens seguintes:
7
8. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Samsung Galaxy
Motorola Milestone
8
9. Luciano Alves da Silva
1.2) Estrutura Geral da plataforma Google Android
O Android SDK é uma ferramenta de desenvolvimento que
disponibiliza um conjunto de APIs necessárias para desenvolver
aplicações para a plataforma Android, utilizando a linguagem
Java.
Vamos conhecer os recursos encontrados nessa plataforma:
- Application framework: Permite a reutilização e substituição
de componentes ;
- Dalvik virtual machine: É uma Máquina Virtual Java (JVM)
voltada para dispositivos móveis ;
- Browser Integrado baseado no webkit engine ;
- Gráficos Otimizados O Android é cosntituído por bibliotecas
2D e 3D baseada na especificação OpenGL ES 1.0 ;
- SQLite: Sistema Gerenciador de Banco de Dados (SGBD) já
embutido no Android para guardar dados ;
- Suporte multimídia: A plataforma já oferece para áudio,
vídeo 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) ;
9
10. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
- Câmera, GPS, compasso, e acelerômetro (dependente de
hardware) ;
- Rico ambiente de desenvolvimento , incluindo um emulador
de dispositivo, ferramentas de depuração, memória,
performance e um plugin para o Eclipse (ADT) ;
1.2.1) A arquitetura do Android
Arquitetura geral da plataforma
1.2.2) Aplicações
O Android nos fornece um conjunto de aplicações
fundamentais, são elas:
- um cliente de e-mail;
- programa de SMS;
10
11. Luciano Alves da Silva
- agenda;
- mapas;
- navegador;
- contatos entre outros.
Todos os aplicativos acima presentes no Android foram
desenvolvidos na linguagem de programação Java.
O Android nos fornece um conjunto de bibliotecas C/C++
utilizadas por vários componentes do sistema. Veja algumas das
bibliotecas abaixo:
- System C library: Consiste em uma implementação derivada
da biblioteca C padrão baseado no sistema (libc) do BSD
sintonizada para dispositivos rodando Linux.
- Media Libraries: Baseado no PacketVideo’s OpenCORE; são
as bibliotecas que suportam os mais diversos formatos de áudio
e vídeo, incluindo também imagens.
- Surface Manager: Responsável pelo acesso ao subsistema de
exibição bem como as múltiplas camadas de aplicações 2D e
3D;
- LibWebCore: Consiste em um web browser engine utilizado
tanto no Android Browser quanto para exibições web.
- SGL – o engine de gráficos 2D
- 3D libraries: Uma implementação baseada no 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.
11
12. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
- FreeType – Biblioteca responsável pela renderização de fontes
bitmap e vector;
- SQLite – Conforme já mencionado, consiste no sistema
gerenciador de banco de dados (SGBD) relacional disponível
para todas as aplicações.
1.2.3) Android Runtime
O Android é costituído por um conjunto de bibliotecas que
fornece a maioria das funcionalidades disponíveis nas principais
bibliotecas da linguagem Java.
Toda aplicação Android roda em seu próprio processo, com sua
própria instância da máquina virtual Dalvik. O Dalvik foi escrito
de forma a executar várias VMs eficientemente. Ele executa
arquivos .dex, que é otimizado para consumo mínimo de
memória. A VM é baseada em registros e roda classes
compiladas pela linguagem Java que foram transformadas em
arquivos .dex, através da ferramenta “dx” incluída no SDK.
O Dalvik VM foi baseado no kernel do Linux para
funcionalidades subjacentes como o encadeamento e a gestão de
baixo nível de memória.
1.2.4) Linux Kernel
O Android foi projetado em cima da versão 2,6 do kernel do
Linux para os serviços centrais do sistema, tais como segurança,
gestão de memória, gestão de processos, etc. O kernel também
atua como uma camada de abstração entre o hardware e o resto
do software.
12
13. Luciano Alves da Silva
2) Instalando e Configurando o Android SDK no Eclipse
P ara a elaboração desse livro eu fiz o uso do Eclipse
Galileo (Eclipse 3.5.1 para Windows), o SDK do
Android Revisão 10 e o plugin do Android para o Eclipse
ADT-10.0.1. Qualquer versão (de preferência superior) dos
programas citados acima serve. Para que toda essa aplicação
funcione é necessário que você tenha instalado, antes de tudo, a
Máquina Virtual Java (de preferência a versão 5 ou posterior).
Bom, mãos a obra.
Para saber se você possui uma Maquina virtual Java entre no
prompt de comando de digite a seguinte linha:
java –version
Se mostrar algo parecido como mostra o código abaixo:
java version "1.6.0_07"
Java(TM) SE Runtime Environment (build 1.6.0_07-b06)
Java HotSpot(TM) Client VM (build 10.0-b23, mixed mode,
sharing)
Significa você possui uma máquina virtual Java instalada no seu
computador, caso contrário, instale o JDK. Você pode fazer o
download do JDK pelo link abaixo:
http://www.oracle.com/technetwork/java/javase/downloads/inde
x.html
13
14. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Se você já possui a máquina virtual Java instalada em seu
computador, basta agora você fazer o download do Eclipse, que
pode ser feita pelo link abaixo:
http://www.eclipse.org/downloads/
Para fazer o download do Android SDK e do seu plugin , faça
pelo link abaixo:
http://developer.android.com/sdk/index.html
Depois de obter os programas e plugins citados acima, vamos
fazer agora as devidas configurações. Primeiramente, você irá
descompactar o arquivo “android-sdk_r10-windows.zip”, de
preferência no diretório raiz “C:”. Depois de descompactar,
execute o utilitário “SDK Manager”, que se encontra dentro da
pasta descompactada, conforme é mostrado na figura abaixo:
Conteúdo do arquivo descompactado
14
15. Luciano Alves da Silva
Ao executá-lo ele irá atualizar as suas fontes , conforme
demonstra a figura seguinte:
Processo de atualização das informações
Ao terminar o processamento acima, ele ira mostrar uma lista de
pacotes disponíveis e necessários para download, como
podemos conferir a figura abaixo:
Lista de pacotes disponíveis para download
15
16. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Vamos cancelar a instalação dos pacotes acima clicando no
botão “Cancel”, pois, não iremos instalar tudo. Feito isso você
irá visualizar a seguinte caixa de diálogo abaixo:
Caixa de diálogo – Installed packages
Precisamos agora instalar a plataforma Android através desta
caixa de diálogo. Clique na seção “Avaiable packages” para
visualizar todos os recursos disponíveis para instalação. Feito
isso expanda a opção “Android Repository” e automaticamente
você verá os recursos disponíveis para download como você
pode conferir na figura abaixo:
16
17. Luciano Alves da Silva
Caixa de diálogo - Available Packages
Nós iremos trabalhar aqui neste livro com a plataforma Android
2.1 API 7, revision 2. Então vamos marcar a opção “SDK
Platform Android 2.1, API 7, revision 2” e em seguida vamos
clicar no botão “Install Selected”, você verá a seguinte caixa de
diálogo abaixo:
Preparando para Instalar o Android
17
18. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Vamos proceder com a instalação clicando no botão “Install”.
Feito isso a plataforma Android 2.1 será instalada, conforme
demonstra a figura abaixo
Instalação do Android em processo
Depois de concluída a instalação do Android será mostrada uma
mensagem pedindo que o ADB seja reiniciado, como demonstra
a figura abaixo:
Mensagem solicitando para reiniciar do adb
Clique em “Yes” para reiniciar a ADB, e o resultado você pode
conferir na figura abaixo.
18
19. Luciano Alves da Silva
Instalação do Android concluída
Uma etapa concluída. Agora vamos instalar o Eclipse com o
plugin do Android. Para instalar o Eclipse simplesmente
descompacte-o em um local apropriado, de preferência no drive
“C:”. Depois disso copie para o drive “C:” o plugin do Android
“ADT-10.0.1.zip”. Feito isso vamos executar o Eclipse. Com o
Eclipse aberto na no menu “Help” / “Install New Software”,
como mostra a figura abaixo:
Install New Software
19
20. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Ao fazer esse procedimento será aberta uma tela conforme
mostra a figura abaixo:
Caixa de diálogo - Install
Para instalarmos o plugin do Android clique no botão “Add”, e
será exibida uma caixa de diálogo conforme mostra a figura
abaixo:
20
21. Luciano Alves da Silva
Caixa de diálogo - Add Site
Agora vamos clicar no botão “Archive” e iremos procurar e
selecionar o plugin do Android “A.D.T-10.0.1.zip”. Preencha o
campo “Name” como mostra a figura abaixo:
Caixa de diálogo - Add Site
Ao clicar em “OK” será mostrada uma tela, conforme demonstra
a figura seguinte:
21
22. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Caixa de Dialogo - Install
Agora expanda o item “Developer Tools” e marque todas as
opções, conforme mostra a figura seguinte:
22
23. Luciano Alves da Silva
Caixa de Dialogo - Install
Após fazer isso clique no botão “Next”, e em seguida será
mostrada a próxima tela, conforme demonstra a figura abaixo:
23
24. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Caixa de Dialogo - Install
Agora, clique no botão “Finish”. Após isso ocorrerá alguns
processos, como demonstra a figura abaixo, aguarde até
terminar.
Instalando do Android no Eclipse
24
25. Luciano Alves da Silva
Se em algum momento durante o processo for exibida a figura
abaixo:
Caixa de mensagem
Pode clicar em “OK” sem problemas, e o processo se
completará. Após o termino do processo você deve reiniciar o
Eclipse, clicando em “Yes”, na mensagem abaixo:
Caixa de mensagem
Após o Eclipse ter reiniciado, vamos fazer agora as
configurações para fazer conexão com o emulador do Android.
Vamos no menu “Window” / “Preferences”. Aberta a caixa de
diálogo, selecione o item “Android” e será mostrada uma tela,
conforme demonstra a figura seguinte:
25
26. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Caixa de diálogo - Preferences
Agora você vai selecionar o diretório onde se encontra o
Android, que aqui no meu computador, o Android se encontra
instalado em “C:android-sdk-windows”, logo, terei que
selecionar essa pasta. Feito isso basta clicar em “OK”.
Para finalizar vamos definir um dispositivo virtual, conhecido
como AVD (Android Virtual Device), onde nossas aplicações
daqui para frente serão executadas. Para isso, vá no menu
“Windows” / “Android SDK and AVD Manager”, conforme
mostra a figura abaixo:
26
27. Luciano Alves da Silva
Android SDK and AVD Manager
Feito o procedimento acima, será aberta uma tela conforme
mostra a figura abaixo:
Caixa de diálogo - Virtual Settings
27
28. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Para criarmos um dispositivo virtual clique no botão “New”, e
será aberta uma tela conforme mostra a figura abaixo:
Caixa de diálogo - Crete new AVD
De inicio, vamos configurar o básico pra executarmos a nossa
aplicação. Em “Name” você define o nome do AVD, vamos
chamá-lo de “Emulador”.
Em “Target” definirmos a plataforma-alvo a ser executada,
neste caso só temos uma o “Android 2.1-update1 - API Level
7”. Vamos selecioná-la.
Em Skin na opção “Built-in” a opção padrão é “Default
(WVGA800)”. Vamos mudar essa opção para “HVGA”.
28
29. Luciano Alves da Silva
Depois de preencher todos os campos, a tela de criação do AVD
deve estar de acordo com a figura abaixo:
Caixa de diálogo - Create new AVD
Para criarmos nosso AVD, clique no botão “Create AVD” e
pronto. O resultado você confere na figura seguinte:
29
30. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
AVD Criado com sucesso
Até aqui aprendemos a instalar e configurar a plataforma
Android no Eclipse. Agora vamos dar nossos primeiros passos
desenvolvendo uma aplicação básica no Android.
30
31. Luciano Alves da Silva
3) Começando a programar no Google Android
D epois de tudo configurado e instalado, vamos começar a
desenvolver nossas aplicações no Android. Para isso,
vamos criar um novo projeto Android indo no menu
“File” / “New” / “Other”. Selecione o projeto Android conforme
figura abaixo. Depois de selecionar, clique em “Next”:
Criando um novo projeto Android no Eclipse
Após clicar em “Next” na figura acima, será exibida uma tela
conforme figura abaixo:
31
32. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Criando um novo projeto Android no Eclipse
Vamos preencher os campos citados abaixo:
Project name : HelloWorldAndroid
Application name : Hello World Android
Package name: br.com.apphello
Create Activity : AppHello
Min SDK Version : 7
32
33. Luciano Alves da Silva
Os campos preenchidos acima devem estar de acordo com a
figura abaixo:
Criando um novo projeto Android no Eclipse
Depois de tudo preenchido basta clicar no botão “Finish” e
pronto, nosso projeto foi criado. Em “Package Explorer”, vamos
dar uma olhada na estrutura do projeto, simplesmente clicando
no botão “+”, é só seguir a figura abaixo. Aproveite e abra o
arquivo “AppHello.java” como também demonstra a figura:
33
34. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Visão geral de uma aplicação Android
Irei descrever a estrutura de um projeto Android. Observem que
dentro da pasta de projeto “HelloWorldAndroid” existe uma
pasta chamada “src”, e dentro dela é que ficam os códigos fontes
das aplicações. Observem que o arquivo “AppHello.java” se
encontra dentro do pacote “br.com.apphello” (Esse pacote
também é uma pasta). Esse arquivo é a nossa aplicação Android.
Vou descrever em detalhes o arquivo “AppHello.java” (Veja o
código abaixo):
package br.com.apphello;
import android.app.Activity;
import android.os.Bundle;
public class AppHello extends Activity {
/** Called when the activity is first created.
*/
34
35. Luciano Alves da Silva
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Diferentemente das aplicações comuns em Java (J2SE), toda
classe para aplicação Android deve ser derivada da classe
Activity (Atividade), e possui como método principal o
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:
Os diretórios “drawable-hdpi”,”drawable-mdpi” e “drawable-
ldpi”.
A partir da versão 1.6 da plataforma Android foram adicionados
três diretórios responsáveis pelo gerenciamento de imagens:
“drawable-hdpi”, “drawable-ldpi”, “drawable-mdpi”. Qual a
diferença de um para outro ? Cada um desses diretórios só será
utilizado de acordo com a resolução do Android em uso, ou seja,
qual modelo de emulador de você estiver usando. Por exemplo,
quando você usa uma resolução de 480x800 no seu emulador, é
35
36. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
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 320x480 (que normalmente é a resolução
padrão do emulador Android), é utilizado o diretório “drawable-
mdpi”. Se você usar uma resolução 240x400, é utilizado o
diretório “drawable-ldpi”.
O diretório “layout” armazena todos os layouts da aplicação
Android, que normalmente são arquivos “.xml”. Para quem
conhece a combinação HTML + JavaScript, no Android é
similar, é a combinação de XML + Java, logo, todos os nossos
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 do SDK) é 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 seguinte:
36
37. Luciano Alves da Silva
Preview da aplicação Android
Para visualizarmos o código do arquivo “main.xml”
simplesmente clique na guia “main.xml”, que se encontra abaixo
da seção “Views” como demonstra a figura seguinte:
37
38. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Preview da aplicação Android
Veja o seu código abaixo:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/a
ndroid"
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>
38
39. Luciano Alves da Silva
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 um componente chamado TextView,
que representa um texto a ser exibido na tela que por padrão, já
vem escrito a frase “Hello World, AppHello”, 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 descrevê-lo agora.
O diretório “values” armazena valores estáticos (constantes)
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 conforme mostra a figura seguinte:
39
40. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Propriedades do arquivo “strings.xml”
Observe que nas propriedades do atributo “hello” está atribuído
um valor a ela, que é o valor “Hello World, AppHello!”. 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, AppHello!”. Para ver a sua estrutura , clique na guia
“strings.xml”. O código desse arquivo é igual ao que demonstra
o código abaixo:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello World,
AppHello!</string>
<string name="app_name">Hello World
Android</string>
</resources>
40
41. Luciano Alves da Silva
Observem que dentro desse arquivo eu declaro um valor estático
chamado “app_name”, cujo valor é “Hello World Android”.
Dentro da pasta “HelloWorldAndroid” 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,
conforme mostra a figura abaixo:
Propriedades do arquivo “AndroidManifest.xml”
Bom, o que nos interessa aqui é o código. Para visualizarmos
seu código clique na seção “AndroidManifest.xml”. Veja seu
código abaixo:
41
42. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
<?xml version="1.0" encoding="utf-8"?>
<manifest
xmlns:android="http://schemas.android.com/apk/res/a
ndroid"
package="br.com.android"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".AppHello"
android:label="@string/app_name">
<intent-filter>
<action
android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Observem algumas tags interessantes. A tag <application>
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).
42
43. Luciano Alves da Silva
Observem agora a tag <activity>, 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”, conforme mostra a figura abaixo:
“Run Configurations”
43
44. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Feito isso, será aberta uma caixa de diálogo com vários itens.
Clique com o botão direito do mouse no item “Android
Application” e selecione a opção New, conforme a figura
abaixo:
Criando um novo “Android Application”
Feito isso, na propriedade “Name” ao lado digite “AppHello”.
Em Project selecione o projeto que criamos em clicando no
botão “Browse”, com o nome de “HelloWorldAndroid”. E por
último, em “Launch Action”, deixe marcada a opção “Lauch
Default Activity”. Qualquer dúvida siga a figura abaixo:
Propriedades do “Android Application”
44
45. Luciano Alves da Silva
Agora é só clicar em “Run” e rodar a aplicação. Quando o
emulador Android é executado, possivelmente, poderá abrir
junto com ele uma caixa de dialogo, conforme a figura abaixo.
Normalmente eu desmarco a opção “Send usage statistics to
Google” e clico em “Proceed”.
Caixa de diálogo do Android SDK
Pra você que está executando pela primeira vez o emulador do
Android, vê que o emulador é uma espécie de SmartPhone.
Lado esquerdo nós temos a tela do dispositivo e no lado direito
temos o teclado com suas funções, conforme mostra a figura
seguinte:
45
46. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Emulador do Android em Execução
No início da execução do emulador mostra o título Android,
conforme você vê na figura acima. Depois vem um outro título
escrito “Android”, com um titulo cinza em animação. Isso
demora em torno de 2 a 10 minutos (dependendo da sua
máquina. É recomendável que você tenha no mínimo 512 MB
de memória e um processador bem rápido para um bom
desempenho da execução) para a aplicação ser exibida, mesmo
sendo essa aplicação algo muito simples.
Passado o tempo que citei acima, será mostrada a nossa
aplicação e também algumas mensagens, é só cancelá-las.
Quando o emulador chegar nessa tela abaixo:
46
47. Luciano Alves da Silva
Emulador do Android em Execução
Clique no botão redondo com o titulo “MENU” para
desbloquear a tela e a aplicação continuará a processar até ser
carregada com sucesso, conforme mostra a figura abaixo:
47
48. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Emulador do Android em Execução
Esse emulador já vem com uma série de recursos como
Navegador, Aplicações de demonstração, Mapas, Lista de
contatos e etc.
Se você neste exato momento fechou o emulador após a
execução da aplicação, vou te dizer uma coisa: “Não era para
você ter feito isso”. Se você esperou muito tempo para ver essa
aplicação em execução, ao executar novamente a aplicação,
você vai esperar o mesmo tempo. Ao executar pela primeira vez
o emulador, e caso vá executar outros programas, minimize o
emulador ao invés de fechar, pois se você esperou muito tempo
para executar esse programa, com ele minimizado, ao executar
outro programa, o Eclipse vai fazer uso do emulador já aberto
48
49. Luciano Alves da Silva
em vez de abrir outro, com isso a aplicação levará em torno de
7 a 12 segundos em média para ser executada. Nunca esqueça
isso!
Vamos modificar essa aplicação. Minimize o emulador e vamos
abrir o arquivo “main.xml”. Na tag TextView que já havia
explicado a vocês, possui um atributo chamado android:text,
onde nele defino o título que será exibido, modifique agora essa
propriedade com o seguinte valor (título), conforme o código
abaixo:
android:text="Fala cara, beleza ???"
Feito isso, salve a aplicação e veja seu “preview”, clicando na
seção “Graphical Layout”. Veja na figura abaixo:
Preview da aplicação
49
50. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Vamos fazer mais uma outra modificação na nossa aplicação.
Abra novamente o arquivo “main.xml”, observe que ele possui
um TextView certo ? Vamos colocar mais dois componentes
TextView, a primeira TextView, no atributo android:text terá
o título “Primeira frase”, o segundo TextView terá o título
“Segunda Frase” e assim sucessivamente. Veja como ficará o
código do arquivo “main.xml” :
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/a
ndroid"
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="Primeira Frase."
/>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Segunda Frase"
/>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Terceira Frase???"
/>
</LinearLayout>
Feito isso, salve o arquivo e veja seu “preview”, como
demonstra a figura abaixo:
50
51. Luciano Alves da Silva
Preview da aplicação
E ai, está entendo aos poucos como se faz aplicações Android ?
Com certeza que sim!
Como podemos ver nessa versão do Android, ele já oferece um
utilitário que permite a criação de aplicações de forma rápida,
simplesmente arrastando e soltando os componentes. Isso
acelera o processo de desenvolvimento de aplicações.
Neste livro, vamos trabalhar no Android usando esse utilitário
que acelera o processo de desenvolvimento de aplicações, mas,
em algumas ocasiões, faremos do modo tradicional, ou seja,
digitar o código.
Agora vamos aprofundar um pouco e fazer aplicações mais
interessantes com o uso dos Widgets (componentes) existentes
na plataforma Android.
51
52. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
4) Conhecendo as widgets do Android
T oda aplicação Android é constituída por widgets, que
são componentes gráficos que constituem uma aplicação
Android. A partir de agora iremos conhecer os widgets
básicos que constituem a plataforma Android, para o
desenvolvimento das aplicações. De acordo com alguns widgets
que fomos conhecendo, vamos desenvolver aplicações que
demonstrem o uso deles.
4.1) A widget TextView
A widget TextView funciona como se fosse uma Label
(“rotulo”), onde nele podemos mostrar alguma informação,
mensagem e etc. Na nossa primeira aplicação tivemos a
oportunidade de usarmos esse componente.
4.2) A widget EditText
A widget EditText funciona como se fosse caixa onde podemos
digitar nela dados do teclado.
4.3) A widget Button
A widget Button nada mais é do que um Botão de comando ,
que quando clicado, dispara uma ação, um evento.
4.4) Desenvolvendo uma aplicação que soma números
Com os componentes até agora vistos, já é possível
desenvolvermos uma aplicação. Vamos criar agora uma
52
53. Luciano Alves da Silva
aplicação que faça uso de um desses widgets. Crie um novo
projeto Android com os seguintes dados:
Project Name: SomaNumeros
Package Name: br.com.appsoma
Create Activity: AppSoma
Application Name: Soma Números
Min SDK Version: 7
Criado o projeto vamos no arquivo “main.xml” desse projeto e
como havia mencionado, vamos agora fazer uso do utilitário que
ira nos ajudar a construir a nossa aplicação da forma rápida.
Pelo nome do projeto, podemos ver que essa aplicação é uma
aplicação de calculo. Essa aplicação vai ler dois números
inteiros e no final, irá mostrar a soma deles, simples.
Vamos no arquivo “main.xml” desse projeto e será carregado o
“layout” dessa arquivo, como mostra a figura abaixo:
53
54. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Primeiramente, antes de qualquer modificação no
programa, vamos mudar a resolução da visualização do layout
da nossa aplicação, para que esteja de acordo com a resolução
do emulador Android. Na opção onde está selecionada como
padrão “2.7in QVGA” , e vamos selecionar a opção “3.2in
HVGA slider (ADP1)” (Essa será a resolução que passaremos a
trabalhar daqui pra frente). Você verá que a resolução mudará ,
como demonstra a figura abaixo:
54
55. Luciano Alves da Silva
Tela de layout da aplicação
Agora vamos fazer as modificações iniciais no programa.
Observe que logo de início, ele mostra a frase “Hello
World,AppSoma!” na widget TextView. Vamos carregar as
propriedades (Properties) dessa widget clicando com o botão
direito sobre ele e em seguida selecione o menu “Show in /
Properties”, como você confere na figura seguinte:
55
56. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Em seguida as propriedades do componente se carregarão,
conforme você pode conferir na figura abaixo:
56
57. Luciano Alves da Silva
Tela de layout da aplicação
Agora vamos na guia “Properties” encontrar uma
propriedade chamada “Text”, que indica o conteúdo assumido
pelo componente TextView, que no caso é a frase “Hello
World,AppHello!”. Depois de encontrar a propriedade Text,
substitua o valor corrente pela frase “Digite o primeiro número”
e depois disso, de ENTER. O resultado você confere na figura
abaixo:
57
58. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Ótimo, agora vamos inserir a widget EditText, que funciona
como um campo para preenchermos com valores numéricos ou
alfanuméricos. Como vamos adicionar esse componente? Se
você observar na figura acima, existe uma seção chamada
“Form Widgets”, é nela onde ficam os componentes básicos que
constituem uma aplicação Android.
Primeiramente, encontre o componente (widget) EditText,
depois de encontrá-lo, simplesmente você vai clicar sobre ele e
arrastar até a tela do dispositivo, para adicioná-lo. O resultado
você confere na figura abaixo:
58
59. Luciano Alves da Silva
Tela de layout da aplicação
Bom, agora vamos modificar duas propriedades desse
componente.
Encontre a propriedade “id” do componente EditText e nela
você vai inserir o valor “@+id/numero1”. Essa propriedade
serve para darmos um nome ao componente, caso ele seja
trabalhado no código Java.
O nome de um widget deve estar nesse formato:
“@+<nome>/<nome>”
59
60. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Se observamos, o valor desse atributo é : “@+id/numero1”. É
como se “id” representasse um grupo e “numero1” representasse
o nome do componente. Você irá entender essa notação mais a
frente.
Depois disso, vamos na propriedade “Layout width”, que define
a largura de um componente e iremos definir o valor
“fill_parent”, que indica que o componente irá ocupar toda a
largura do dispositivo.
Para finalizar, vamos agora modificar a propriedade “Text“,
deixando seu conteúdo em branco. O resultado você confere na
figura abaixo:
Tela de layout da aplicação
60
61. Luciano Alves da Silva
Agora você vai inserir, NA SEQUÊNCIA, os componentes
TextView e EditText.
Na segunda TextView, vamos inserir na propriedade “Text” a
frase “Digite o segundo número”.
Já na segunda EditText, vamos repetir os mesmos
procedimentos que fizemos na primeira EditText, sabendo-se
que a diferença vai estar na propriedade “id” que assumirá o
valor “@+id/numero2”. Somente essa é a diferença, o resto é
tudo igual.
Agora vamos inserir um componente chamado Button na nossa
aplicação. Depois de inserido, modifique as propriedades abaixo
com os seus respectivos valores:
Button
Propriedade Valor
Layout width fill_parent
Id @+id/btsomar
Text Somar
Depois de feito todas as alterações, o layout da aplicação deve
estar de acordo com a figura abaixo:
61
62. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Bom, agora vamos analisar o código produzido. Para
visualizarmos o código produzido, basta clicar na guia
“main.xml” . O código produzido você confere abaixo:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/a
ndroid"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
62
63. Luciano Alves da Silva
android:layout_height="wrap_content"
android:text="Digite o primeiro número"/>
<EditText android:layout_height="wrap_content"
android:id="@+id/numero1"
android:layout_width="fill_parent"></EditText>
<TextView android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Digite o segundo número"></TextView>
<EditText android:layout_height="wrap_content"
android:layout_width="fill_parent"
android:id="@+id/numero2"></EditText>
<Button android:layout_height="wrap_content"
android:layout_width="fill_parent"
android:id="@+id/btsomar"
android:text="Somar"></Button>
</LinearLayout>
Vamos analisar o código:
Dentro da estrutura LinearLayout temos um componente
TextView, identificado pela tag <TextView......></TextView>.
Dentro desse componente possuímos as propriedades
android:layout_width (Layout Width), que possui o valor
“fill_parent” ; android:layout_height (Layout Height), que
possui o valor “wrap_content” ; android:text (Text) que possui
o valor “Digite o primeiro número”.
Em seguida temos o componente EditText, identificado pela tag
<EditText......></EditText>. Dentro desse componente
possuímos as propriedades android:layout_width ,
android:layout_height e android:id (Id) que possui o valor
“@+id/ednumero1” (que equivale ao nome do componente).
63
64. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
A descrição acima da estrutura dos componentes e das
propriedades segue também para os componentes seguintes.
Beleza, agora vamos abrir o código do arquivo
“AppSoma.java”, para acessar via código Java os componentes
que adicionamos via XML. Siga os passos aqui descritos para
você ver como esse processo é feito. Após a linha
import android.os.Bundle;
Digite:
import android.widget.*;
import android.view.*;
import android.app.*;
Antes da linha:
@Override
Digite:
EditText ednumero1,ednumero2;
Agora vamos à explicação do código acima. Como você pode
ver , os widgets também podem ser usados no nosso código
Java. Se no código XML eu possuir um widget do tipo EditText
para acessar esse componente pelo Java, é preciso fazer uso da
classe EditText. Cada widget no XML possui o seu respectivo
em classe Java, logo, se possui um widget Button, para acessá-
lo devo fazer uso da classe Button e assim vai.
64
65. Luciano Alves da Silva
Agora, após a linha:
setContentView(R.layout.main);
Digite as seguintes linhas de código:
ednumero1 = (EditText) findViewById(R.id.numero1);
ednumero2 = (EditText) findViewById(R.id.numero2);
Button btsomar = (Button)
findViewById(R.id.btsomar);
Agora vou explicar as linhas acima. A linha:
ednumero1 = (EditText) findViewById(R.id.numero1);
Faz referência ao primeiro EditText, através do método
findViewById com o parâmetro “R.id.numero1”.
Se lembra o nome da primeira EditText que está no código
XML? Ela se chama “@+id/numero1”.
Vamos entender. Observe que para fazer referência ao EditText
pelo método findViewById eu passei o parâmetro
“R.id.numero1”.
65
66. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Já na segunda linha, para fazer a referência à segunda EditText,
cujo nome é “@+id/numero2”, pelo método findViewById,
passei o parâmetro “R.id.numero2”.
Como você pode ver, estou fazendo uso da classe R que
funciona como interface entre o código Java e o arquivo XML.
O procedimento é o mesmo para o componente Button.
Agora iremos adicionar um evento “Click”, no nosso Button,
pois quando eu clicar no botão, ele deverá mostrar a soma dos
números. Então, logo após a linha:
Button btsomar = (Button)
findViewById(R.id.btsomar);
Insira o código abaixo:
btsomar.setOnClickListener(new
View.OnClickListener(){
public void onClick(View arg0) {
double num1 =
Double.parseDouble(ednumero1.getText().toString());
double num2 =
Double.parseDouble(ednumero2.getText().toString());
double res = num1 + num2;
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppSoma.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Soma:" + res);
dialogo.setNeutralButton("OK", null);
dialogo.show();
66
67. Luciano Alves da Silva
}
});
Toda vez que eu clicar no botão ele irá mostrar o resultado da
soma na tela através de uma caixa de mensagem. Ótimo! Vamos
executar a nossa aplicação? Para executar faça os mesmos
procedimentos que já mostrei. O resultado da execução dessa
aplicação você vê na figura abaixo:
Aplicação que soma números em execução
OBS: Provavelmente durante a execução da aplicação ao entrar
com um número, deve ter surgido no dispositivo um teclado
67
68. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
virtual (como mostra a figura acima), para ocultar ele é só
pressionar ESC.
Irei descrever o código do evento “Click”. O método
setOnClickLisneter serve para definir um evento de “Click” a
um componente. Como parâmetro, criamos uma instância de
OnClickListener e dentro dessa instância existe o método
chamado onClick, que será disparado toda vez que o botão for
clicado.
A linha:
double num1 = Double.parseDouble(ednumero1.
getText().toString());
Cria uma variável chamada num1 e atribui a ela o valor que está
contido em num1. Eu faço uso do método parseDouble da
classe Double pois o conteúdo é uma String. Observem que
chamo o método getText de ednumero1 para retornar o
conteúdo. Diferente de muitos métodos de retorno String, esse
método getText não retorna uma String, mais sim um tipo
chamado Editable. Por isso, chamei o método toString de
getText para que me retornasse uma string. A descrição da
próxima linha e a mesma.
O código abaixo:
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppSoma.this);
dialogo.setTitle("Aviso");
dialogo.setMessage("Soma:" + res);
dialogo.setNeutralButton("OK",
null);dialogo.show();
68
69. Luciano Alves da Silva
É responsável por mostrar a soma na tela através da classe
AlertDialog.Builder, responsável por criar caixas de diálogo e
exibi-las.
Muito bem, com esse conhecimento adquirido até agora, você já
tem capacidade para fazer uma aplicação básica em Android.
4.5) A widget AutoCompleteTextView
A widget AutoCompleteTextView é uma widget baseada no
EditText que possui um mecanismo “auto complete” , que
funciona como um mecanismo de busca de certas palavras de
acordo com o que está sendo digitado no componente. Vamos
demonstrar o uso desse componente.
Project Name: ExemploAutoCompleteTextView
Package Name : br.com.appautocomplete
Create Activity: AppAutoComplete
Application Name: Exemplo com AutoCompleteTextView
Min SDK Version: 7
Depois de criar o projeto, carregue o layout do arquivo
“main.xml” e em seguida selecione o componente TextView e
vamos na propriedade Text para alterar o texto dele com a
seguinte frase “Digite o nome de um país”.
Agora precisamos inserir o componente (widget)
AutoCompleteTextView. Ele também se encontra na seção
69
70. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
“Form Widgets”. Muito provável que você não esteja vendo
esse componente, então, como faço para visualizá-lo ? Observe
que onde se encontra a guia “Properties” (Propriedades dos
componentes), existem outras guias como “Problems”,
“Javadoc” e etc. Precisamos “minimizar essas guias para
podermos ver todas as widgets da seção “Form Widgets”. Para
minimizar essas guias , clique no botão localizado à direita bem
depois da guia “Properties”, no local indicado pela a figura
abaixo:
Botão minimizar
Feito isso você verá todos os componentes da seção “Form
Widgets” inclusive o componente “AutoCompleteTextView”.
Vamos inserir esse componente e em seguida mude suas
propriedades como demonstra a figura abaixo:
Propriedade Valor
Text
Id @+id/ednomepais
Layout_width fill_parent
A tela da nossa aplicação terá que estar de acordo com a figura
abaixo:
70
71. Luciano Alves da Silva
Layout da aplicação
Feito isso vamos no arquivo “AppAutoComplete.java” e vamos
adicionar o seguinte código abaixo:
package br.com.appautocomplete;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
public class AppAutoComplete extends Activity {
/** Called when the activity is first created.
*/
AutoCompleteTextView ednomepais;
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
71
72. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_l
ist_item_1, paises);
ednomepais = (AutoCompleteTextView)
findViewById(R.id.ednomepais);
ednomepais.setAdapter(adapter);
}
private final String[] paises = new String[]
{ "Afeganistão", "África do Sul",
"Albânia","Alemanha",
"Andorra","Angola",
"Anguila","Antárctida" "Azerbaijão",
"Baamas", "Bangladeche","Brasil",
"Canadá", "Catar",
"Cazaquistão", "Chade",
"Chile","China","Chipre",
"Clipperton Island",
"Dhekelia", "Dinamarca",
"Domínica", "Egipto",
"Equador", "Eritreia",
"Eslováquia", "Eslovénia",
"Espanha", "Estados Unidos",
"Grécia", "Gronelândia",
"Ilhas Salomão", "Ilhas Turcas e Caicos",
"Indonésia", "Irão",
"Iraque"};
}
Vamos analisar alguns trechos de código abaixo. A linha :
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_l
ist_item_1, paises);
72
73. Luciano Alves da Silva
Cria um objeto do tipo Array através da classe ArrayAdapter e
carregamos em seus parâmetros um vetor (array de Strings) pré-
definido com o nome dos países chamado paises.
A linha abaixo:
ednomepais.setAdapter(adapter);
Carrega o vetor no componente através do método “setAdapter”.
E na linha seguinte:
private final String[] paises = new String[]
{....}
Havíamos definido o array de Strings paises onde nele estão
definidos os países onde alguns deles serão exibidos durante o
processo de sugestão do componente.
Bom, agora vamos rodar a nossa aplicação. Veja como ficou na
figura seguinte:
Demonstração do uso AutoCompleteTextView
73
74. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
4.6) A widget CheckBox
A widget CheckBox funciona como um componente que pode
ser marcado e desmarcado, e que possui também um rótulo.
4.7) Desenvolvendo uma aplicação simples de compras
Vamos fazer uma outra aplicação Android que vai fazer uso da
widget CheckBox, que acabamos de conhecer acima. Nossa
aplicação consiste em um simples sistemas de compras onde
possuo cinco produtos, Arroz (R$ 2,69) , Leite (R$ 5,00) , Carne
(R$ 10,00), Feijão (R$ 2,30) e Refrigerante coca-cola (R$ 2,00).
Nessa aplicação eu marco os itens que quero comprar e no final
o sistema mostra o valor total das compras.
Bom, vamos criar um novo projeto chamado
SistemaDeCompras. Siga os dados do projeto abaixo:
Project Name: SistemaDeCompras
Package Name : br.com.appcompra
Create Activity: AppCompra
Application Name: Sistema de Compras
Min SDK Version: 7
Vamos no arquivo “main.xml” desse projeto para carregarmos
seu layout. Depois de carregado, modifique o valor da
74
75. Luciano Alves da Silva
propriedade Text da TextView com a frase “Escolha seu
produto”. Feito isso, adicione os seguintes componentes, na
sequência:
CheckBox
Propriedade Valor
Text Arroz (R$ 2,69)
Id @+id/chkarroz
CheckBox
Propriedade Valor
Text Leite (R$ 5,00)
Id @+id/chkleite
CheckBox
Propriedade Valor
Text Carne (R$ 9,70)
Id @+id/chkcarne
CheckBox
Propriedade Valor
Text Feijão (R$ 2,30)
Id @+id/chkfeijao
75
76. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Button
Propriedade Valor
Text Total das compras
Id @+id/btotal
Layout_width fill_parent
Ao final, o layout da nossa aplicação deve estar de acordo com a
figura seguinte:
Layout da tela da aplicação
Agora vamos modificar o arquivo “AppCompra.java“. O código
desse arquivo será como o código que é exibido abaixo:
76
78. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
double total =0;
if(chkarroz.isChecked())
total += 2.69;
if(chkleite.isChecked())
total += 5.00;
if(chkcarne.isChecked())
total += 9.7;
if(chkfeijao.isChecked())
total += 2.30;
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppCompra.this);
dialogo.setTitle("Aviso"); //Defino o título
dialogo.setMessage("Valor total da compra :" +
String.valueOf(total)); //colocando a mensagem que
vai ter dentro do Dialog
dialogo.setNeutralButton("OK", null); //adicionando
o botão de OK
dialogo.show(); //mostrando o Dialog
}
});
}
}
Descrevendo o código do método onClick : Dentro do método
eu crio uma variável chamada total que armazena o valor total
da compra. Observe que eu tenho quatro estruturas if’s onde
78
79. Luciano Alves da Silva
cada uma verifica se um determinado item foi marcado, se foi,
incrementa o valor do item com o valor da variável total. No
final mostro valor total das compras na tela.
Vamos roda nossa aplicação? O resultado você confere na figura
seguinte:
Aplicação simples de compras em execução
79
80. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
4.8) A widget RadioButton
A widget RadioButton é um componente muito utilizado em
opções de múltipla escolha, onde somente uma única opção
pode ser selecionada.
4.9) Desenvolvendo uma aplicação de cálculo de salário
(Com RadioButton)
Bom, agora vamos fazer uma outra aplicação. Essa aplicação
que vamos desenvolver agora consiste em um sistema que vai
ler o salário de um funcionário e vai permitir que você escolha o
seu percentual de aumento que pode ser de 40% , 45% e 50% e
no final o sistema irá mostrar o salário reajustado com o novo
aumento.
Bom, vamos lá! Crie um novo projeto Android com os seguintes
dados:
Project Name: CalculoDeSalario
Package Name : br.com.appsalario
Create Activity: AppSalario
Application Name: Cálculo do salário
Min SDK Version: 7
80
81. Luciano Alves da Silva
Nessa primeira versão da aplicação, como havia falado, vamos
fazer uso da widget RadioButton.
Carregado o arquivo “main.xml”, modifique a propriedade Text
da TextView com a frase “Digite seu salário (R$)”. Em seguida
adicione os seguintes componentes, na sequência :
EditText
Propriedade Valor
Text
Id @+id/edsalario
Layout_width fill_parent
TextView
Propriedade Valor
Text Qual é o seu percentual ?
Seguindo os passos acima ate aqui, a aplicação deve estar de
acordo com o dá figura abaixo:
81
82. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação Cálculo de salário
Bom, agora vamos adicionar um componente ou melhor, uma
estrutura que será responsável por agrupar as RadioButtons
dentro dela, que se chama RadioGroup. Nesta versão do
Android o RadioGroup já oferece por padrão três
RadioButtons, que é quantidade necessária para a nossa
aplicação. Essa estrutura também se encontra dentro da seção
“Form Widgets” e para adicionar este componente no
dispositivo, simplesmente clique e arraste ele até a tela do
dispositivo. O resultado você confere na figura abaixo:
82
83. Luciano Alves da Silva
Estrutura RadioGroup inserida
Com o RadioGroup selecionado, modifique as propriedades
abaixo:
Propriedade Valor
Layout Width fill_parent
Id @+id/rgopcoes
Observe que dentro do RadioGroup existem três RadioButtons,
cada uma telas identificada por um nome. Se você observar no
Eclipse, à direita da tela da aplicação, existe uma seção chamada
“Outline” onde nela posso visualizar toda a estrutura dos
83
84. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
componentes que estão na minha aplicação. Confira na figura
abaixo:
Guia “Outline”
Agora modifique as propriedades das RadioButons de acordo
com as indicações abaixo:
radio0
Propriedade Valor
Text 40%
Id @+id/rb40
radio1
84
85. Luciano Alves da Silva
Propriedade Valor
Text 45%
Id @+id/rb45
radio2
Propriedade Valor
Text 50%
Id @+id/rb50
Agora, vamos adicionar uma Button, simplesmente clicando e
arrastando o componente na tela. Agora um detalhe, é para
colocar esse componente na tela do dispositivo mas FORA da
área do RadioGroup.
Depois de colocar o Button, modifique as propriedades abaixo:
Propriedade Valor
Text Calcular novo salário
Id @+id/btcalcular
Layout_width fill_parent
Depois de inserir todos os componentes citados, o layout da
aplicação deve ficar de acordo com a figura abaixo:
85
86. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Layout da tela da aplicação
Vamos analisar agora parte de um trecho de código produzido.
Como havia falado acima, as RadioButtons precisam ficar
dentro de uma estrutura chamada RadioGroup certo ? Vamos
ver como isso é estruturado dentro de um código XML, como
você confere abaixo:
<RadioGroup android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="vertical"
android:id="@+id/rgopcoes">
<RadioButton android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="40%"
android:checked="true"
android:id="@+id/rb40"></RadioButton>
<RadioButton android:layout_width="wrap_content"
android:layout_height="wrap_content"
86
87. Luciano Alves da Silva
android:text="45%"
android:id="@+id/rb45"></RadioButton>
<RadioButton android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="50%"
android:id="@+id/rb50"></RadioButton>
</RadioGroup>
Observe acima que logo após a definição da estrutura
RadioGroup, existe dentro dela as RadioButtons, que serão
utilizadas na aplicação.
No arquivo “AppSalario.java”, coloque o código abaixo:
package br.com.appsalario;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
import android.app.*;
public class AppSalario extends Activity {
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Button btcalcular = (Button)
87
88. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
findViewById(R.id.btcalcular);
btcalcular.setOnClickListener(new
View.OnClickListener(){
public void onClick(View arg0) {
double salario, novo_sal;
EditText edsalario = (EditText)
findViewById(R.id.edsalario);
salario = Double.parseDouble
(edsalario.getText().toString());
RadioGroup rg = (RadioGroup)
findViewById(R.id.rgopcoes);
int op = rg.getCheckedRadioButtonId();
if(op==R.id.rb40)
novo_sal = salario + (salario * 0.4);
else
if(op==R.id.rb45)
novo_sal = salario + (salario * 0.45);
else
novo_sal = salario + (salario * 0.5);
AlertDialog.Builder dialog = new
AlertDialog.Builder(AppSalario.this);
dialog.setTitle("Novo salário");
88
89. Luciano Alves da Silva
dialog.setMessage("Seu novo salário é : R$" +
String.valueOf(novo_sal));
dialog.setNeutralButton("OK", null);
dialog.show();
}
});
}
}
Vamos à explicação de alguns códigos interessantes. Dentro do
método onClick, eu realizo o cálculo do novo salário do
funcionário. Os primeiros códigos do evento são similares de
programas anteriores que já foram devidamente explicados. A
linha:
int op = rg.getCheckedRadioButtonId();
Cria uma variável op e retorna para ela o Id da opção
selecionada, ou seja, qual RadioButton foi selecionada.
Agora na condição:
if(op==R.id.rb40)
Verifico se a opção de 40% foi selecionada, se estiver, realiza o
cálculo do salário com o reajuste de 40%. A mesma explicação e
89
90. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
válida para o cálculo dos outros reajustes. Agora vamos executar
a nossa aplicação. O resultado você vê na figura abaixo:
Aplicação de cálculo de salário em execução
4.10) A widget Spinner
A widget Spinner é um componente do tipo caixa de
combinação (“ComboBox”) onde nele é armazenado vários
itens a serem selecionados. Para que um componente possa ser
selecionado, é preciso clicarmos na seta , para que os itens
possam ser mostrados e , por consequência, serem selecionados.
90
91. Luciano Alves da Silva
4.11) Desenvolvendo uma aplicação de cálculo de salário
(Com Spinner)
Bom, agora vamos criar a nossa segunda versão do aplicativo
acima, usando agora o componente Spinner. Crie um novo
projeto Android com os seguintes dados:
Project Name: CalculoDeSalarioSpinner
Package Name : br.com.appsalariospinner
Create Activity: AppSalario
Application Name: Cálculo do salário
Min SDK Version: 7
Nessa segunda versão da aplicação, vamos fazer uso da widget
Spinner. Carregue o arquivo “main.xml” e faça os mesmos
procedimentos do programa anterior, só que ao invés de
adicionar a RadioGroup com os RadioButtons, você vai inserir
somente um componente Spinner. Segue abaixo as
propriedades do Spinner que você precisa modificar:
Propriedade Valor
Id @+id/spnopcoes
Layout_width fill_parent
Seguindo os passos, a aplicação deve estar de acordo com a
figura abaixo:
91
92. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Tela de layout da aplicação
Agora no arquivo “AppSalario.java”, coloque o seguinte código:
package br.com.appsalariospinner;
import android.app.Activity;
import android.os.Bundle;
import android.widget.*;
import android.view.*;
import android.app.*;
public class AppSalario extends Activity {
private static final String[] percentual =
{"De 40%","De 45%","De 50%"};
ArrayAdapter<String> aPercentual;
Spinner spnsal;
92
94. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
case 1: novo_sal = salario + (salario *
0.45); break;
case 2: novo_sal = salario + (salario *
0.5); break; }
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppSalario.this);
dialogo.setTitle("Novo salário");
dialogo.setMessage("Seu novo salário é : R$"
+ String.valueOf(novo_sal));
dialogo.setNeutralButton("OK", null);
dialogo.show();
}
});
}
}
Observando o código do programa acima, podemos ver que ele
é similar o da primeira versão do aplicativo, porém, quero
comentar alguns códigos interessantes desta aplicação. Observe
que foi necessário declarar um “array” de “String” chamado
percentual, conforme mostra o código abaixo:
private static final String[] percentual =
{"De 40%","De 45%","De 50%"};
Este “array” possui três elementos, correspondentes ao
percentual do aumento do salário. Também foi necessário
94
95. Luciano Alves da Silva
declarar um objeto do tipo ArrayAdapter chamado
aPercentual. Esse objeto serve para fazer referencia ao “array”
percentual. Dentro do método OnCreate, existe uma linha de
código abaixo:
aPercentual = new
ArrayAdapter<String>(this,android.R.layout.simple_s
pinner_item, percentual);
Que cria uma instância da classe ArrayAdapter e atribuo essa
instância ao objeto aPercentual, onde carrego nele o “array” de
Strings percentual. Logo depois, vem a instrução:
spnsal.setAdapter(aPercentual);
Onde carrego no objeto do tipo Spinner uma lista de opções de
percentual.
Vamos agora dentro do evento OnClick do objeto Button.
Dentro existe o código mostrado abaixo:
switch(spnsal.getSelectedItemPosition()) {
case 0: novo_sal = salario + (salario *
0.4); break;
case 1: novo_sal = salario + (salario *
0.45); break;
case 2: novo_sal = salario + (salario *
0.5); break; }
Que verifica qual será o novo salário , de acordo com a opção
selecionada no objeto Spinner. Vamos entender esse código.
Observe que o objeto spnsal, possui um método chamado
getSelectedItemPosition, que é responsável por retornar o
95
96. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
índice do item selecionado, sabendo se que o primeiro item
possui índice zero, o segundo possui índice um e assim por
diante. Observe que dentro dessa estrutura eu verifico a opção
selecionada, se for a primeira, o novo salário terá aumento de
40%, se for a segunda , o aumento será de 45% senão, o
aumento será de 50%.
Logo após o cálculo do novo salário, é exibido na tela o novo
salário.
Vamos executar a nossa aplicação. O resultado da execução
você confere na figura abaixo:
Aplicação de cálculo de salário usando Spinner em execução
96
97. Luciano Alves da Silva
4.12) A widget ListView
A widget ListView é um componente que possui vários itens a
serem selecionados, similar ao componente Spinner. A única
diferença entre o ListView e o Spinner é que no componente
ListView os itens já são mostrados sem nenhuma necessidade
de se clicar em alguma parte dele para que os mesmos possam
ser mostrados.
4.13) Desenvolvendo uma aplicação de lista telefônica
Agora vamos fazer uma nova aplicação em Android. Essa
aplicação consiste em uma lista telefônica já pronta com
contatos. Quando selecionamos um contato, ele mostra na tela
uma mensagem com o nome selecionado. A nossa aplicação vai
fazer uso do widget chamado ListView, que exiba uma lista
contendo valores que podem ser selecionados.
Bom, vamos criar um novo projeto. Siga os dados abaixo:
Project Name: ListaTelefonica
Package Name : br.com.applista
Create Activity: AppLista
Application Name: Lista de contatos
Min SDK Version: 7
Vamos no layout do nosso arquivo “main.xml” e vamos
modificar o conteúdo na TextView, com a frase : “Escolha um
97
98. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
contato”. Depois disso, vamos inserir um ListView (que se
encontra na guia “Composite”) e depois iremos modificar suas
propriedades, conforme abaixo:
Propriedade Valor
Id @+id/lstcontatos
Layout_width fill_parent
A aplicação depois de feito todos os passos acima, deve estar de
acordo com a figura abaixo:
Layout da tela da aplicação
No arquivo AppList.java, coloque o seguinte código:
package br.com.applista;
import android.app.Activity;
98
99. Luciano Alves da Silva
import android.app.AlertDialog;
import android.os.Bundle;
import android.widget.*;
import
android.widget.AdapterView.OnItemClickListener;
import android.view.*;
public class AppLista extends Activity {
public ListView lista;
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.simple_l
ist_item_1, contatos);
lista = (ListView)
findViewById(R.id.lstcontatos);
lista.setAdapter(adapter);
lista.setOnItemClickListener(new
OnItemClickListener(){
public void
onItemClick(AdapterView parent, View view, int
position, long id) {
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppLista.this);
dialogo.setTitle("Contato selecionado");
dialogo.setMessage(((TextView)
view).getText().toString());
dialogo.setNeutralButton("OK", null);
99
100. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
dialogo.show();
}
});
}
static final String[] contatos = new String[] {
"Alline","Lucas","Rafael","Gabriela","Silvana"
};
}
Vamos analisar alguns códigos acima. A linha:
static final String[] contatos = new String[] {
"Alline","Lucas","Rafael","Gabriela","Silvana"
};
Cria uma constante chamada contatos, onde nela coloco alguns
nomes. Essa constante vai ser utilizada pela nossa lista. Para que
eu possa carregar dos dados em uma ListView, preciso fazer
uso da classe ArrayAdapter, como mostra a instrução abaixo:
100
101. Luciano Alves da Silva
ArrayAdapter<String> adapter = new
ArrayAdapter<String>(this,android.R.layout.
simple_list_item_1, contatos);
A instrução mostrada acima cria uma instância da classe
ArrayAdapter chamada adapter onde carrego nela o vetor de
Strings da constante contatos. A instrução:
lista.setAdapter(adapter);
Carrega os valores para a ListView, que está contido o objeto
adapter.
Como havia falado, quando se clica em um item, o sistema
mostraria uma mensagem do item selecionado. Isso é
conseguido fazendo uso da interface OnItemClickListener,
como mostra a instrução abaixo:
lista.setOnItemClickListener(new
OnItemClickListener(){
public void onItemClick(AdapterView parent,
View view, int position,long id) {
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppLista.this);
dialogo.setTitle("Contato selecionado");
dialogo.setMessage(((TextView) view).getText()
.toString());
dialogo.setNeutralButton("OK", null);
dialogo.show();
101
102. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
});
Toda vez que clicarmos em um item da lista, o método
onItemClick será disparado e será executado o comando
abaixo:
AlertDialog.Builder dialogo = new
AlertDialog.Builder(AppLista.this);
dialogo.setTitle("Contato selecionado");
dialogo.setMessage(((TextView) view).getText()
.toString());
dialogo.setNeutralButton("OK", null);
dialogo.show();
Que exibe o nome do item selecionado. O item selecionado está
em um objeto View, que precisa ser convertido para um objeto
do tipo TextView, para que o método getText possa ser
invocado retornando em uma String o item selecionado .
Vamos executar a aplicação. O resultado você vê na figura
abaixo:
102
103. Luciano Alves da Silva
Aplicação de lista de contatos em execução
4.14) A widget Imageview
A widget ImageView é um componente que permite que
visualizemos imagens dentro dele. As imagens suportadas por
esse componente são imagens no formato JPEG, GIF e PNG.
4.15) Desenvolvendo uma aplicação que visualiza imagens
(Com ImageView)
Agora vamos desenvolver uma aplicação que visualiza imagens,
usando o componente ImageView.
103
104. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Agora crie um novo projeto conforme os dados abaixo:
Project Name: VisualizadorDeImagens
Package Name : br.com.appimagem
Create Activity Name: AppImagem
Application Name: Visualizador de Imagens
Min SDK Version: 7
Antes de iniciarmos a codificação do programa, quero que você
coloque duas imagens JPEG (com a extensão .jpg), dentro da
pasta “res/drawable-mdpi” (para esse projeto usei duas imagens
chamadas “foto1.jpg” e “foto2.jpg”). Para importar um arquivo,
clique com o botão direito do mouse sobre a pasta
“res/drawable-mdpi” e selecione “Import”, depois selecione File
System (Que se encontra dentro da pasta “General”). Clique no
botão browser para selecionar o diretório onde se encontram as
imagens, depois de selecionado, marque os dois arquivos
(imagens) para que eles sejam importados para a pasta
“res/drawable-mdpi” . Veja a figura abaixo:
104
105. Luciano Alves da Silva
Importando imagens para aplicação
Depois disso, é só clicar em “Finish”.
Agora no layout do arquivo “main.xml” apague o componente
TextView que se encontra na tela do dispositivo. Feito isso, siga
os passos abaixo para construirmos a nossa aplicação.
Vamos adicionar dentro da tela da nossa aplicação uma estrutura
LinearLayout (que se encontra na guia “Layouts”)
simplesmente arrastando o componente para a tela da aplicação.
O resultado você confere na figura abaixo:
105
106. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Estrutura LinearLayout inserida
Agora nessa estrutura LinearLayout que inserimos, vamos
modificar a seguinte propriedade abaixo:
Propriedade Valor
Orientation horizontal
Logo após a alteração da propriedade, a estrutura LinearLayout
que inserimos “perdeu foco”. Se você clicar novamente no local
onde você inseriu estrutura é muito provável que você não
consiga selecioná-lo (isso normalmente acontece com essa
estrutura) . Para solucionar esse problema simplesmente
selecione esta estrutura pela guia “Outline”, como demonstra a
figura abaixo:
106
107. Luciano Alves da Silva
Selecionando a estrutura LinearLayout
Agora dentro da estrutura LinearLayout que configuramos
acima, vamos inserir o componente ImageView (que se
encontra na guia “Images & Media”), e em seguida mude as
seguintes propriedades:
ImageView
Propriedade Valor
Id @+id/imagem
Src @drawable/foto1
Bom antes de prosseguir, quero explicar a propriedade “Src”.
Nessa propriedade definimos a imagem corrente que irá
aparecer na tela que é especificada pela notação
“@drawable/foto1” (lembre-se que uma das imagens que
utilizei para o projeto chama-se “foto1.jpg”), irei explicar essa
notação.
107
108. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Se você notou, quando importamos as duas imagens que seriam
utilizadas pelo nosso programa, essas imagens ficaram dentro do
diretório “drawable-mdpi” certo ? Porém, quando especificamos
pela propriedade “Src” o nome do diretório das imagens sempre
será “@drawable”. Outro detalhe: Quando especificamos o
nome do arquivo de imagem, o nome do arquivo não pode ter a
extensão dele, isso é regra.
TextView
Propriedade Valor
Id @+id/txtinfo
Text Foto 1
Seguindo os passos acima, o resultado do layout deve ficar de
acordo com a figura abaixo:
Layout da aplicação
108
109. Luciano Alves da Silva
Agora vamos colocar na sequência dois Buttons, só que esses
dois componentes vão estar dentro da tela da aplicação , ou seja
, da estrutura principal. Segue abaixo as propriedades que
precisam ser modificadas:
Button1
Propriedade Valor
Id @+id/btimagem1
Text Exibir foto 1
Layout_width fill_parent
Button2
Propriedade Valor
Id @+id/btimagem2
Text Exibir foto 2
Layout_width fill_parent
Depois de seguir todos os passos descritos acima, a aplicação
tem que estar de acordo com a figura abaixo:
109
110. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Layout da aplicação
Agora no arquivo “AppImage.java” coloque o código abaixo:
package br.com.appimagem;
import android.app.Activity;
import android.os.Bundle;
import android.view.*;
import android.widget.*;
public class AppImagem extends Activity {
ImageView imagem;
TextView txt;
@Override
110
112. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
Agora vamos analisar alguns trechos de códigos. Vamos no
evento Click referente a abertura da primeira imagem. O
código:
imagem.setImageResource(R.drawable.foto1);
É responsável por abrir a imagem “foto1.jpg” e exibi-la no
componente. Observe que foi passado o parâmetro
“R.drawable.foto1” onde “drawable” corresponde a pasta e
“foto1” corresponde ao arquivo “foto1.jpg”. Logo após vem o
código:
txt.setText("Foto 1");
Cuja finalidade é mudar o título da TextView , de acordo com a
String passada como parâmetro.
O comentário acima é o mesmo para o segundo botão referente
à abertura da segunda imagem.
Vamos executar a nossa aplicação. O resultado você vê nas
imagens abaixo:
112
113. Luciano Alves da Silva
Aplicação de visualização de imagens em execução
(mostrando a foto 1)
Aplicação de visualização de imagens em execução
(mostrando a foto 2)
113
114. Aprenda passo a passo a programar em Android - Guia essecial para
desenvolvedores
4.16) A widget Gallery
Na aplicação anterior, fizemos uso do widget ImageView. Note
que usamos a mesma widget para visualizar duas imagens
distintas. Agora nesta segunda aplicação vamos fazer uso da
widget Gallery, que funciona como um grupo do ImageViews
onde cada foto pode ser visualizada simplesmente arrastando o
mouse ou clicando nas setas direitas ou esquerda do SmartPhone
. Veja na figura abaixo uma aplicação que faz uso dessa
estrutura:
4.17) Desenvolvendo uma aplicação que visualiza imagens
(Com Gallery)
Bom, vamos a nossa aplicação. Crie um novo projeto de acordo
com os dados abaixo:
Project Name: GaleriaDeImagens
Package Name : br.com.appgallery
Create Activity: AppGallery
Application Name: Galeria de Imagens
Min SDK Version: 7
114