julho2013

julho2013

julho2013 03

19

Autor: Thiago C. MontebugnoliÍndice

27

Editorial

04

11

Autor: Hamden Vogel

05

Autor: Luciano Pimenta

Autor: José Antonio P. M. de Paula

As principais mudanças Delphi XE4

FastReport no Delphi

TConexao:Gerenciando seu projeto em ambientes Multi-Plataforma – parte 1

AndroidTrabalhando com o TouchScreen

julho201304

Delphi é marca registrada da Borland International, as demais marcas citadas são registradas

pelos seus respectivos proprietários.

Thiago Montebugnoli - Editor Chefethiago@theclub.com.br

Caro Leitor!

É sempre com muita alegria e satisfação que finalizamos mais uma re-vista aos senhores. Aproveito também para agradecer às pessoas que vem acessando o conteúdo de nosso site, portanto a cada dia que passa estamos adquirindo mais acessos e cadastros. Que continuemos assim!

Para este mês, nosso consultor técnico José Antonio nos trouxe direto do forno as principais novidades do Delphi XE4 com o intuito de sempre mantê-los bem informados com as últimas tecnologias lançadas no merca-do. Nosso colunista mensal Luciano Pimenta aborda o uso do gerador de relatórios “FastReport”, uma boa opção para quem trabalha com o Delphi. Podemos considerar esta ferramenta como a opção oficial para quem utiliza as novas versões do Delphi. Já nosso colaborador Hamden Voguel desenvolveu um componente próprio para gerenciar projetos em ambientes Multi-Plataforma, o “TConexao”. Nesta primeira parte ele irá nos auxiliar na gerência de Projetos utilizando diversos tipos de Banco de Dados. Im-portante salientar que este componente está disponível gratuitamente em nosso site. Eu continuo apresentando recursos do Sistema Android, sendo que neste mês ensino a trabalhar com o “TouchScreen”, descrevendo suas principais classes e métodos para realizar esta tarefa. Recomendo a leitura deste artigo para quem está começando a desenvolver aplicativos e para quem deseja aprimorar seus conceitos em relação a este artifício.

Um forte abraço e até o mês que vem!

Av. Profº Celso Ferreira da Silva, 190 Jd. Europa - Avaré - SP - CEP 18.707-150

Informações e Suporte: (14) 3732-1529

Internethttp://www.theclub.com.br

Cadastro: cadastro@theclub.com.brSuporte: suporte@theclub.com.br Informações: info@theclub.com.brSkype Cadastro: theclub_cadastro

Skype Suporte: theclub_linha1 theclub_linha2 theclub_linha3

www.twitter.com/theclubbr

Copyright The Club 2013

Diretor TécnicoMarcos César Silva

DiagramaçãoVitor M. Rodrigues

DesignVitor M. Rodrigues

RevisãoDrielly Cristini Patrinhani

ColunistasJoão Marcos Sakalauska

José Antonio P. M. de PaulaLucas de OliveiraLuciano Pimenta

Thiago Cavalheiro Montebugnoli

JuninhoJeferson Silva de Lima

Impressão e acabamento:GRIL - Gráfica e Editora

Taquarituba-SP - Tel. (14) 3762-1345

ReproduçãoA utilização, reprodução, apropriação, armazenamento em banco de dados, sob qualquer forma ou meio, de textos, fotos e outras criações intelectuais em cada publicação da revista “The Club Megazine” são terminantemente proibidos sem autorização escrita dos titulares dos direitos autorais.

Editorial

julho2013 05

FastReport é um gerador de relatórios presente no Delphi desde a sua versão 4. A partir da versão XE2, passou a ser a ferramenta de relatórios “oficial” do Delphi. Com o FastReport podemos criar poderosos relatórios pra nossas aplicações Win32 e FireMonkey com Delphi.

A ferramenta ainda possui suporte (adquirido separadamente) para .NET, Mono e Lazarus. Possui ainda uma ferramenta chamada FastCube para análise de dados e construção de relatórios e gráficos (OLAP), uma ferramenta de scripts (FastScript) e o FastQueryBuilder, construtor visual de consultas SQL.

Para ver exemplos e outras informações sobre essas ferramentas, acesse: www.fast-report.com/pt/. Nesse artigo, vamos conhecer a versão do FastReport que acompanha o Delphi XE4, aprendendo a criar relatórios simples, agrupados, formatações e muitos outros exemplos.

Conhecendo a ferramenta

Ao abrir o Delphi e criar um projeto VCL Foms, podemos visualizar a aba FastReport 4.0 (Figura 1).

Figura 1. Aba do Fast Report no Delphi

Trabalharemos para criar relatórios simples, usando dois componentes: o frxReport e o frxDBDataSet. O primeiro é o editor de relatórios, onde basta dar um duplo clique que teremos o ambiente de criação dos relatórios (Figura 2). O segundo faz a ponte, entre os dados e o relatório.

Figura 2. Ambiente de desenvolvimento de relatórios (fonte: FastReport User’s Manual)

Baseado na Figura 2, destacamos a seguir as principais janelas e editores.

1. Report designer: local onde vamos adicionar as bandas e os objetos para o relatório;

2. Barra de menus;3. Barra de ferramentas: botões com as opções de carregar relatórios,

criar novos, salvar etc;4. Barra de ferramentas do objeto: objetos que podem ser adicionados

ao relatório;5. Report page tabs: abas para configuração da página do relatório;6. Report tree: janela onde podemos visualizar as bandas e objetos

inseridos no relatório;7. Object Inspector: janela para definição das propriedades dos objetos

do relatório;8. Data tree: janela com os objetos de dados do relatório. Podemos

FastReport no Delphi

julho201306

arrastar facilmente um campo para o relatório;9. Régua;10. Status line: semelhante a uma barra de status, com informações

sobre o objeto selecionado no relatório.

Primeiro exemplo

Volte ao Delphi e adicione um frxDBDataSet (um frxReport também deve estar no formulário). Crie uma conexão com o banco de dados de sua preferen-cia (usarei no artigo, o Firebird). Usarei no artigo um Data Module para conter os componentes de conexão com o banco, pois usaremos vários exemplos.

Vincule o frxDBDataSet com o DataSet que retorna os dados da sua consul-ta. Dê um duplo clique no frxReport para abrir o editor. Primeiramente, vamos vincular o frxDBDataSet com o nosso relatório, acessando o menu Report>Data. No editor que abrir, escolha o respectivo controle de dados (Figura 3).

Figura 3. Vinculando o componente de dados com o relatório

Vamos agora, adicionar as bandas do relatório. Clique no botão Insert Band na barra de ferramentas de objetos. Conforme vemos na Figura 4 é mostrado um menu suspenso que todas as opções de banda.

Figura 4. Adicionando bandas ao relatório

Adicione os tipos: Page Header, Page Footer e Master Data. O Master Data, abre um editor, solicitando o respectivo DataSet da aba. Selecione frxDBDa-taSet1. Existem duas maneiras de adicionar os campos na banda Master Data para exibir os dados.

Arraste os campos da janela Data tree para o relatório. Note que após inserir os campos, ao passar o mouse, é mostrado uma seta, onde podemos clicar e será exibido um menu com os campos do DataSet, assim fica fácil modificar o objeto para outro campo da consulta (Figura 5).

Figura 5. Mudando o campo do objeto facilmente

Outra maneira de adicionar os campos no relatório é escolhendo um Text object na barra de ferramentas e adicionando o mesmo no relatório. Será aberto um editor com alguns botões (Figura 6).

Figura 6. Editor do Text Object

No editor, temos abas onde vamos configurar o formato do campo, formatações de fonte etc. o primeiro botão da aba Text, acessa outro editor, onde podemos escolher os campos da consulta, variáveis do relatório, funções, etc (Figura 7).

julho2013 07

Figura 7. Editor de expressões do relatório

Podemos usar o editor do Text Object para apenas adicionar rótulos (tex-tos) no relatório, onde basta digitar o texto desejado na aba Text. Na barra de ferramentas temos as funcionalidades necessárias para formatar os textos digitados nesse objeto.

Note que ao adicionarmos um Text Object ou mesmo adicionar um campo usando a janela Data tree, existem linhas que nos auxiliam para que os contro-les fiquem alinhados tanto horizontalmente, como verticalmente (Figura 8).

Figura 8. Alinhando os componentes do relatório

Feche o relatório. No Delphi, adicione um botão e adicione o seguinte código em seu evento OnClick:

frxReport1.ShowReport();

Execute a aplicação e visualize o relatório em funcionamento (Figura 9).

Figura 9. Relatório de listagem em execução

Formatação de objetos

Como podemos ver no relatório que criamos, o campo Salary, esta como texto, sem a devida formatação. Para ajustar isso, abra o relatório e dê um duplo clique no campo. No editor, acesse a aba Format e configure, conforme a Figura 10, onde indicamos o tipo de formatação e o separador decimal (vírgula) do formato.

Figura 10. Relatório de listagem em execução

Nem precisamos executa o projeto novamente, basta acessar o botão de preview no próprio ambiente do relatório para visualizar as modificações. E se precisássemos modificar a formatação de um objeto (fonte, cor etc) de acordo com algum parâmetro que existisse, como faríamos? É bastante simples.

Acesse o objeto que deseja modificar a formatação. Dê um duplo clique para acessar o editor e a aba Highlight. Na opção Condition, digite: “<frxDBDataset1.”SALARY”> > 50000”. Marque em Font a opção Bold. O bo-tão Color, indica a cor do texto quando a condição do objeto for verdadeira.

Você também pode usar o botão para acessar o editor de expressões para montar a mesma manualmente. De acordo com o configurado antes, o campo Salary do relatório deve aparecer em vermelho quando o valor desde for maior que 50.000,00. Veja na Figura 11 nosso exemplo em execução.

Figura 11. Formatação condicional do relatório

Caso você deseje mudar a formatação de todo “a linha”, para que não precise fazer manualmente a configuração de cada objeto, basta selecionar todos os objetos e acessar a propriedade HighLight>Condition e fazer a mesma configuração anterior.

Outra formatação bastante usada é a de indicar a quantidade de páginas e

julho201308

Código 01

Código 02a página atual do relatório. O FastReport possui variáveis que retornam essas informações e que são fáceis de serem utilizadas.

Acesse a aba Variables do Data tree e arraste para o formulário um Date e um TotalPages. Para customizar esses variáveis, basta dar um duplo clique e digitar o texto que deseja. Veja na Figura 12 o rodapé do relatório (modifiquei o mesmo para mostrar mais de uma página).

Figura 12. Formatação do rodapé do relatório

Nota: Para adicionar um texto, basta digitá-lo no editor, tomando o cuidado de não remover a variável.

Arquivos de relatórios

Para você que estava acostumado com o Rave Reports, vai notar uma diferença interessante no FastReport. Cada relatório é um arquivo FR3. No Rave, o arquivo RAV era de projeto e dentro poderíamos ter vários relatórios.

No FastReport, cada FR3, é apenas um relatório. Salve o arquivo e modi-fique o código do botão para o seguinte código:

frxReport1.LoadFromFile(‘Listagem.fr3’);frxReport1.ShowReport();

Nota: caso o FastReport não encontre o arquivo, nenhum erro é mostrado, apenas o relatório não exibe nenhum registro.

Usamos o método LoadFromFile para carregar o arquivo de relatório no frxReport. Isso nos dá a facilidade de termos apenas um controle e vários relatórios, sendo carregados de acordo com a nossa necessidade.

Agrupamento

Outro exemplo muito usado em relatórios é o de agrupamento de dados. Neste exemplo, vamos fazer a mesma listagem anterior, com a diferença que vamos retornar todos os empregados, agrupados pelo seu departamento.

Veja o SQL da consulta:

select EMPLOYEE.first_name, EMPLOYEE.last_name, employee.salary, DEPARTMENT.departmentfrom EMPLOYEEinner join DEPARTMENT on DEPARTMENT.dept_no = EMPLOYEE.dept_noorder by DEPARTMENT.department

Crie um novo frxReport (se desejar, em outro formulário). Caso seja car-regado o relatório anterior, crie um novo. Não esqueça de modificar o Data do relatório. Caso tenha criado um novo formulário, atende para o nome do formulário no editor de seleção de DataSets (Figura 3).

De um duplo clique no Master Data e vincule com o DbDataSet. Adicione uma banda Group Header. Um editor é aberto para configurarmos a banda do grupo. Vamos indicar que o agrupamento se dará pelo campo Department. Podemos ainda indicar uma expressão para o agrupamento.

Nas opções de agrupamento, podemos configurar para que a cada grupo, seja mostrado em uma nova página ou drill-down, onde clicamos sobre o grupo para mostrar os dados.

Dica: caso você escolha a opção drill-down ao executar o relatório, apenas os grupos serão mostrados. É necessário clicar em cima do mesmo para exibir os registros.

Arraste a banda para que fique acima da Master Data. Veja na Figura 13 o relatório agrupado em execução.

Figura 13. Relatório agrupado

julho2013 09

Somatório

Sempre que usamos agrupamento de dados em um relatório, precisamos somar um determinado campo ou contar a quantidade de registros. Vamos aproveitar esse relatório para fazer esse exemplo. Adicione uma banda Grou-pFooter no relatório.

Adicione um Text Object e acesse o botão Insert Aggregate da aba Text. No editor, vamos configurar um campo que terá seu valor somado, que no caso é Salary. Veja na Figura 14 como ficou a configuração.

Figura 14. Configurando o somatório do grupo

Faça a formatação no campo, semelhante ao campo Salary. Rode o relatório e note que temos o somatório por grupo. Mas e se quisermos o valor total no final do relatório? Basta adicionar uma banda ReportSummary e fazer a mesma configuração anterior.

Veja na Figura 15 o relatório com somatório do grupo e somatório total.

Figura 15. Somatórios no relatório

Dica: temos uma opção bem interessante na configuração do somatório. Caso precisássemos mostrar um somatório acumulado por grupos, basta marcar a opção Running total na janela Insert Agreggate (Figura 14). Assim, a cada final de grupo, teríamos um somatório acumulado.

Master/detail

Outro exemplo muito comum em relatório e de mostrar os dados mas-ter e os details. Exemplo clássico: nota fiscal, os dados referente ao cliente (comprador) podemos considerar o master, e as informações dos produtos da nota, são o detail.

Essas duas fontes de dados, precisam ter um relacionamento. Primeiro, teremos duas consultas separadas, uma para a master e outra para detail. Nesse exemplo, estou pesquisando os empregados (Employee) e o histórico de salários (Salary_History). Precisaremos, portanto de dois frxDBDataSet (um para cada consulta).

O relacionamento, faremos nos componentes de consulta, o que é bas-tante simples. Adicione um DataSource e faça a ligação com a consulta master. No componente (ClientDataSet, Query, Table etc) com os dados da consulta detail, acesse a propriedade MasterSource e escolha o DataSet anterior. Em MasterFields, acesse o editor e configure o campo de relacionamento (nesse caso Emp_no).

Crie um novo relatório e adicione as seguintes bandas: Page Header, Master Data, Detail Data e Page Footer. Na Master Data você deve configu-rar o frxDBDataSet que tem os dados do máster (no exemplo, Employee) e consequentemente, para o Detail Data, os dados do detail (Salary_History).

Veja na Figura 16 a disposição dos campos nas duas bandas.

Figura 16. Relatório master/detail

Execute o relatório e veja que os dados estão agrupados de acordo com o nome do empregado.

Exportação de relatórios

Uma característica interessante que observei no FastReport é a quantidade de opções de tipos de exportações para os relatórios. Veja na Figura 17 a aba de exportações do FastReport.

Figura 17. Tipos de exportações do FastReport

julho201310

Para exportar, por exemplo, um relatório para HMTL, basta adicionar no formulário um frxHTMLExport. Acesse a IDE de desenvolvimento e execute o preview do relatório. Note que um botão foi adicionado para exportar o relatório.

Para cada tipo de exportação, um item de menu será adicionado no preview do relatório (Figura 18).

Figura 18. Opções de exportação no preview do relatório

Na versão comercial do FastReport, diferente da versão que acompanha o Delphi, existe a opção de envio do relatório por e-mail. Ao clicar no compo-nente, um editor será mostrado. Nele, na aba E-mail configuramos para quem o relatório será enviado, assunto, corpo do e-mail e escolhendo o formato desejado (Figura 19).

Na aba Account, configuramos o e-mail de envio, ou seja, as nossas con-figurações de e-mail para o envio do mesmo.

Figura 19. Editor para envio por e-mail do relatório

Conclusões

Vimos nesse artigo como trabalhar com o FastReport, a “nova” ferramenta para gerar relatórios no Delphi. Existem muitas outras possibilidades para criarmos relatórios profissionais para suas aplicações Delphi, assim, no pró-ximo artigo veremos como criar gráficos, cross-tab, trabalhar com templates (semelhante à herança) etc.

Um grande abraço a todos e até a próxima!

www.lucianopimenta.net

Luciano PimentaLuciano Pimenta (NOVO DOMINIO: www.lucianopimenta.com) é desenvolvedor Delphi/C#

para aplicações Web com ASP.NET, Windows com Win32 e Windows Forms com .NET. Palestrante da 4ª edição da Borland Conference (BorCon) e da 1ª Delphi Conference.

É MVP Embarcadero, grupo de profissionais que ajudam a divulgar o Delphi no mundo. Atualmente é desenvolvedor da SoftDesign fábrica de softwares em Porto Alegre-RS.

Autor de mais de 90 artigos e de mais de 600 vídeos aulas publicadas em revistas e sites especializados, além de treinamentos presenciais e multimídias. É consultor da FP2 Tecnologia (www.fp2.com.br) onde ministra cursos de programação e banco de dados.

Sobre o autor

julho2013 11

Imagino que muitos desenvolvedores já experimentaram a situa-ção de avaliar um protótipo em mais de um ambiente, talvez ao mesmo tempo (homologação em um ambiente em uma máquina local e entrega em outro ambiente através de uma “build”). Nestes casos, pode um mesmo Banco de Dados satisfazer tais requisitos

de performance e regras negociais exigidas, executando comumente um “CRUD” sem comprometer a “rapidez” do tráfego de dados atualizando de forma imperceptível os controles projetados na camada de apresentação do seu aplicativo – até aí tudo bem – mas e se houver a necessidade negocial de evolutivamente abstrair a camada de dados ? O seu aplicativo “decide” qual base ele irá rodar – e sem prejuízo de instabilidade – este processo será transparente para o usuário final.

Porque não implantar uma forma otimizada de se obter eficientemente esta característica de multiplataforma? O Framework Itil já dizia: “As Empresas buscam inovar seus processos para se tornarem mais eficientes e competiti-vas. Inovações que dão certo transformam-se em melhores práticas”. Esta implementação já foi devidamente testada, é livre, tem uma boa resposta de execução, é acessível a todos e por isso justifica-se em uma boa prática de serviço. Ambiciosamente podemos entregar este valor em potencial levando ao aumento dos resultados desejados dos clientes. Em suma, mais do que funciona.

O cliente tem uma exigência que é crescente; nós devemos estar sempre preparados para prontamente atendê-las; podemos no caso de um entrega rodá-la localmente em um pen-drive ou em seu próprio HD com um baixo vo-lume de dados utilizando um arquivo XML (apenas para verificar basicamente seu funcionamento e sem muitos requisitos de software), ou executá-la em um ambiente de desenvolvimento cliente-servidor exigindo todos os requisitos im-plementados até o momento, simulando realmente sua performance e demais quesitos (disponibilidade, confiabilidade, sustentabilidade, etc) – escalando qual dataset ele irá acessar – e em tempo de execução! Portanto, imagine um software ser independente do seu banco de dados - e aqui é referido de forma abstrata – valendo-se tanto de um mero arquivo XML (construí um parser para isso), tanto para um Sistema baseado em Arquivos ou um Sistema Gerenciador de Banco de Dados: tem para estas três finalidades - e finalmente o sistema está independente de tudo: nasce a classe Tconexao.

TConexao: Gerenciando seu projeto em ambientes Multi-Plataforma parte 1

Nós temos a seguinte missão de fazer todo o “meio-de-campo” entre a camada de apresentação e a de negócio: enquanto as telas do cliente fazem as chamadas para as classes de negócio, elas por sua vez vão se comunicar com a nossa classe de conexão para chamar o banco de dados desejado, processan-do a chamada (select, update, etc) e finalmente a retornando (um dataset, stringlist, etc) - conforme pode ser entendido pela figura abaixo:

Figura 01 - Como as camadas se comunicam com a classe TConexao. Enquanto que uma camada chama, outra sempre a escuta e resolve.

Esta funcionalidade é interessante pela praticidade, como dito anterior-mente, pois o aplicativo fica livre de implementações distintas de acesso aos dados; apenas a nossa classe de conexões fará este trabalho de carregamen-to e alteração deles – toda visualização é produzida pelo carregamento do componente TClientDataSet – ele sempre será alimentado pela nossa classe – portanto eles sempre andarão juntos – um sempre se comunicando com o outro – e consequentemente a base em que ele acessará será sempre desli-gada, esperando algum evento do usuário ou sistema, como por exemplo de “comitar” um “update” ou carregar uma lista (para inicialização de uma tela ou um “refresh”).

Abaixo pode ser visualizado o diagrama de sequência do componente, a fim de exemplificar o seu funcionamento na prática; não é complicado perceber sua idéia básica de funcionamento.

Figura 02 - Diagrama de Sequência do componente TConexao.

julho201312

Código 01

Agora, finalmente, o processo completo de funcionamento de acordo com a orientação a objetos juntamente com a nossa classe:

Figura 03 - Explicação da operacionalização do funcionamento das camadas juntamente com as regras negociais e com a classe TConexao.

Primeiros Passos com a classe TConexao:

O primeiro passo a seguir é criar um data-módulo contendo a conexão com o banco; pelo menos nesta versão o nosso projeto não tem suporte a metadados; pretendo em uma próxima versão automatizar a criação e detecção de banco de dados em tempo de execução, onde os bancos são reconhecidos e listados mas apenas com um TDataModule – ele será criado e destruído a cada alteração de solicitação de bases – mas isso é tema para outra release deste componente.

Por agora, devemos estar atentos de que nenhuma conexão deverá estar pré-configurada porque isso é o dever da classe de conexão realizar – e tam-pouco este data-módulo recém-criado deverá estar associado ao projeto - ele deve ser removido dele. Lembre-se sempre de que a aplicação (referindo-se às telas da camada de apresentação e às classes negociais) “não conhece” o banco de dados a ser chamado - a classe cria o data-módulo dinamicamente, executa as operações desejadas retornando ou não o seu processamento e após sua utilização ela é destruída: e como ficam os acessos data-aware, que eram utilizados para acessar diretamente um banco de dados qualquer, editando informações até mesmo de dentro de uma célula de um TDBGrid e consequentemente gravando e “comitando” a transação tudo “de uma vez só”? A resposta agora é o TClientDataSet - ele vai representar em memória nosso DataSet e exibir com qualquer componente data-aware desejado - sem impactar diretamente uma transação com o banco de dados - qualquer transação será feita agora pela classe TConexao, pois através dela solicitará as transações com o banco de dados, cuidando totalmente de sua persistência.

Continuando, o segundo passo é acrescentar neste data-módulo um ClientDataSet para cada classe que será utilizada e persistida na aplicação: como a classe de conexão e as demais utilizam a abordagem orientada a objetos, cada ator no sistema será realmente um objeto negocial; no nosso exemplo existe um ator usuário, portanto foi criada uma classe TUsuario para ele, e assim por diante.

O terceiro e último passo são os métodos (personalizados) que deverão ser criados para manipulação total de seu novo acesso ao banco de dados: deverão ser implementadas chamadas de configuração, dll´s necessárias (que deverão ser levadas juntas ao executável e mais o client do banco, se for o caso) e demais arquivos necessários para o seu gerenciamento, agora encapsulado pela nossa classe TConexao.

Algumas recomendações:

Não utilizar arquivos arquivos de conexão. Fazer diretamente de dentro da classe;

Não utilizar ODBC: Fazer diretamente de dentro da classe; Não permitir que a aplicação (telas da camada de apresentação) e

nem tampouco as camadas de negócio (nosso exemplo o TUsuario) acessem quaisquer parâmetros de banco de dados ou sequer se comuniquem com ele: tudo isso é dever EXCLUSIVO da classe TConexao.

Portanto, basicamente o processo de criação para um novo banco finaliza--se aqui; não é difícil estendê-lo.

O importante sempre é criar um banco de dados primeiro e depois suas implementações, sempre estendendo a classe TConexao, criando uma nova subclasse que irá sobreescrever os métodos BancoExiste, FecharBanco, CarregarBanco, RecordCount, RetornaDataSet e ObterDataSet – cruciais para operações básicas de funcionamento – consulta, inclusão, alteração e exclusão – além de outros métodos descendentes de TDataSet (recordcount).

A seguir, um trecho do código-fonte do método “CarregarBanco” de uma conexão para o Firebird:

function TConexaoFirebird.CarregarBanco(const cDiretorio: string): Boolean;begin Result := True; if (cDiretorio = EmptyStr) then begin fVendorLib := FMyGDSVendorLib; fLibraryName := FMyDBXExpress FirebirdLibraryName; fPathDataBase := FUsuariosFDB; end else if (cDiretorio = ‘default’) then begin fVendorLib := FMyGDSVendorLib; fLibraryName := ExtractFilePath(Application.ExeName) + IncludeTrailingPathDelimiter (‘BD\FIREBIRD’) + FMyDBXExpressFire birdLibraryName; fPathDataBase := ExtractFilePath (Application.ExeName) + IncludeTrailingPathDelimiter (‘BD\FIREBIRD’) + fPathDataBase; end else begin fVendorLib := cDiretorio + FMyGDSVendorLib;

julho2013 13

Código 02

fLibraryName := cDiretorio + FMyDBXExpress FirebirdLibraryName; fPathDataBase := cDiretorio + fPathDataBase; end;

Result := ( (DirectoryExists (fPathDataBase)) and (FileExists (fLibraryName)) ); if not Result then Exit;

dmFirebird := TdmFirebird.Create(nil);

try try with dmFirebird.SQLConnection do begin Connected := False; VendorLib := dbVendorLib; LibraryName := dbLibraryName; Params.Values[‘Database’] := fPathDataBase + FUsuariosFDB; end; finally dmFirebird.SQLConnection.Connected := True; dmFirebird.SQLQuery.Open; end; except on E: Exception do begin Raise EInvalidDataBase.Create (EErroGeralBancoDeDados + #13#10 + E.Message); Result := False; end; end;end;

Nossa classe tem 3 bancos pré-definidos e configurados que já podem ser prontamente utilizados em qualquer aplicação, dando início a um desen-volvimento de código mais “facilitado” graças a esta abstração de conexões, porque não será mais necessário criar outras conexões para o mesmo banco em diferentes forms ou um criar um data-módulo e associá-lo à aplicação, pois como isso tudo já foi feito, basta apenas chamar a classe de negócio (no nosso caso de exemplo, a TUsuario).

São os Bancos:

XML DBISAM FIREBIRD

Segue também para distribuição o DDL da tabela:

CREATE TABLE USUARIOS ( CD_USUARIO INTEGER, NOME VARCHAR(200), DATANASCIMENTO DATE, ENDERECO VARCHAR(200), CIDADE VARCHAR(10), ESTADO VARCHAR(3), CEP VARCHAR(20), CARGO VARCHAR(200), SETOR VARCHAR(200), TELEFONE VARCHAR(20), FOTO BLOB SUB_TYPE 0 SEGMENT SIZE 500, VLR_SALARIO FLOAT, NR_MATRICULA INTEGER);

No nosso projeto foram criados campos dos tipos String, Integer, Float e Blob. Todos os tipos serão validados de acordo com o formato suportado pelo banco – isto é – nem todos possuem as mesmas validações para data, ponto flutuante, etc. Um ponto importante a ser mencionado é que todos os setters são do tipo String – isso facilita os testes de validação de tipo de dados antes de sua conversão para o seu formato original.

Alguns campos são obrigatórios, requeridos nos setters e retornando um campos de mensagens de retorno (FCodigoMensagem e FMensagem).

Uma amostra do fonte da propriedade da data de nascimento (método write):

procedure TUsuario.setDataNascimento(const Value: String); //obrigatóriovar AuxDia, AuxMes, AuxAno, fValue: string;begin fValue := Value; fValue := Conexao.GetDateFormat(Value); if not (Biblioteca.EmptyDate(fValue)) then

julho201314

Código 03

Código 04

begin if not Biblioteca.IsValidDate(fValue) then begin FCodigoMensagem := CodMensagemCampoInvalido; FMensagem := ‘Campo Data Nascimento Inválido!’; FDataNascimento := ‘’; end else begin FCodigoMensagem := CodMensagemNormal; FMensagem := EmptyStr; FDataNascimento := Conexao.FormatDefaultDate(fValue); //Trim(Value); end; end else begin FDataNascimento := fValue; FCodigoMensagem := CodMensagemCampoEmBranco; FMensagem := ‘Campo Data Nascimento em Branco!’; Alterou := False; end;end;

Agora, um exemplo do código-fonte padrão para verificar se existe um registro e em caso positivo atualizá-lo:

Query := ‘SELECT * FROM USUARIOS WHERE NOME = ‘ + QuotedStr(Nome);

if Conexao.RecordCount(Query) > 0 then //atualiza begin Query := ‘UPDATE USUARIOS SET ENDERECO = ‘ + QuotedStr(Endereco) + ‘, DATANASCIMENTO = ‘ + QuotedStr(Conexao.FormatDate(DataNascimento)) +

‘, CIDADE = ‘ + QuotedStr(Cidade) + ‘, ESTADO = ‘ + QuotedStr(Estado) + ‘, CEP = ‘ + QuotedStr(CEP) + ‘, CARGO = ‘ + QuotedStr(Cargo) + ‘, SETOR = ‘ + QuotedStr(Setor) + ‘, TELEFONE = ‘ + QuotedStr(Telefone) + ‘, VLR_SALARIO = ‘ + (Conexao.FormatFloat(Salario)) + ‘, NR_MATRICULA = ‘ + (Conexao.FormatInteger(Matricula)) + ‘ WHERE NOME = ‘ + QuotedStr(Nome); Conexao.Executar(Query); end

Explicação: A classe TConexao, através de GetConexao, e utilizando o type tBDConexao (type tBDConexao = (bdConexaoXML, bdConexaoDBISAM, bdConexaoFirebird) – fará a instanciação com a subclasse desejada de acesso ao banco, e a melhor de todas as coisas é que em runtime os bancos podem ser trocados – selecionando, alterando, etc – com a maior versatilidade!

Em suma, toda vez que uma classe quiser acessar um banco, ela na verdade acessa uma instância da classe de conexão (TConexao), onde esta por sua vez referenciará-lo em memória. Toda a interface de comunicação e operacionaliza-ção será realizada somente através dela, estando disponível até ser destruída.

Abaixo, uma seleção de alguns métodos importantes utilizados na classe TConexao - detalhe para os métodos ObterDataSet, CarregarFoto e GetCo-nexao (sintaxe: Conexao := Conexao.GetConexao(fbdConexao)) - que são os métodos mais importantes do processo de comunicação entre os objetos de negócio e dados.

procedure TConexao.ObterDataSet(const myDataSet: TDataSet; var myClientDataSet: TClientDataSet);var fDataSet: TDataSet; i {, k}: integer; FName: string;begin if not Assigned(myDataSet) then Exit; if not Self.BancoInstanciado then begin Application.MessageBox(PChar(Format(EBancoNaoInstanciado, [FUsuariosFDB])), ETituloErro, MB_OK + MB_ICONERROR);

julho2013 15

Abort; end; fDataSet := TClientDataSet(myDataSet); fDataSet.First; if not myClientDataSet.Active then myClientDataSet.CreateDataSet else myClientDataSet.EmptyDataSet;

myClientDataSet.DisableControls; try while not fDataSet.Eof do begin myClientDataSet.Insert; for i := 0 to fDataSet.FieldCount - 1 do begin // myClientDataSet.Fields[i].Assign(fDataSet.Fields[i]);

myClientDataSet.FieldDefs.Items[i].DataType := (fDataSet.FieldDefs.Items[i].DataType); myClientDataSet.FieldDefs.Items[i].DisplayName := (fDataSet.FieldDefs.Items[i].DisplayName); case myClientDataSet.FieldDefs.Items[i].DataType of ftString: myClientDataSet.Fields[i].AsString := Self.DefaultDateFormat2(fDataSet.Fields[i].AsString); ftDate: myClientDataSet.Fields[i].AsString := Self.DefaultDateFormat2(fDataSet.Fields[i].AsString); ftFloat: myClientDataSet.Fields[i].AsFloat := Biblioteca.ArredondaComDecimais( fDataSet.Fields[i].AsFloat, 2);

else myClientDataSet.Fields[i].AsString := fDataSet.Fields[i].AsString; end;

end; myClientDataSet.Post; fDataSet.Next; end; finally myClientDataSet.EnableControls; end;end;

procedure TConexao.ObterDataSet(const myDataSet: TDataSet; var myStringList: TStringList);var fDataSet: TDataSet; i: integer;begin if not Assigned(myDataSet) then Exit;

fDataSet := TClientDataSet(myDataSet); fDataSet.First;

if not Assigned(myStringList) then myStringList := TStringList.Create; while not fDataSet.Eof do begin myStringList.Add(fDataSet.Fields[0].AsString); fDataSet.Next; end;end; function TConexao.RecordCount(Query: String): integer;begin if Self is TConexaoDBISAM then Result := TConexaoDBISAM(Self).RecordCount(Query) else if Self is TConexaoXML then Result := TConexaoXML(Self).RecordCount(Query) else if Self is TConexaoFirebird then Result := TConexaoFirebird(Self).RecordCount(Query);end;

function TConexao.

julho201316

RecordCount(const myDataSet: TDataSet): integer;begin Result := (TDataSet(myDataSet).RecordCount);end;

function TConexao.RetornaDataSet(Query: String): TDataSet;begin if Self is TConexaoDBISAM then Result := TConexaoDBISAM(Self).RetornaDataSet(Query) else if Self is TConexaoXML then Result := TConexaoXML(Self).ExecutaSelect(Query) else if Self is TConexaoFirebird then Result := TConexaoFirebird(Self).RetornaDataSet(Query);end;

function TConexao.CarregarFoto(const MyFile: string; const myDataSet: TDataSet; const MyFieldName: string = ‘FOTO’): Boolean;function GetTableNameFromXMLSyntax(const mySQLXML: string): string;begin if System.Pos(AnsiUpperCase(‘where’), AnsiUpperCase(mySQLXML)) > 0 then Result := trim(Before(after(AnsiUpperCase(mySQLXML), ‘FROM’), ‘WHERE’));end;var S: TFileStream; fClientDataSet: TClientDataSet; auxTableName: string; auxFilterFields: string;begin if Self is TConexaoXML then begin if (Self.FiltroXML = ‘’) then Exit;

auxTableName := GetTableNameFromXMLSyntax(Self.FiltroXML); auxTableName := auxTableName + ‘.xml’; fClientDataSet := TConexaoXML(Self).CarregarBanco(auxTableName); auxFilterFields := Before(after(AnsiUpperCase(Self.FiltroXML),’WHERE’), ‘ORDER’); fClientDataSet.Filter := auxFilterFields; fClientDataSet.Filtered := True; try fClientDataSet.Close; fClientDataSet.Open;

if not (fClientDataSet.state in dsEditModes) then fClientDataSet.Edit;

TBlobField(fClientDataSet.FieldByName(MyFieldName)).LoadFromFile(MyFile); fClientDataSet.Post; fClientDataSet.SaveToFile(TConexaoXML(Self).CaminhoXMLAtual, dfXML); except on E: Exception do begin Raise EInvalidDataBase.Create(EErroGeralBancoDeDados + #13#10 + E.Message); Result := False; end; end; end else if Self is TConexaoDBISAM then begin S := TFileStream.Create(MyFile ,fmOpenRead); with (myDataSet) do begin try try Edit; TBlobField(Fie

julho2013 17

Código 05

ldByName(MyFieldName)).LoadFromStream(S); Post; except on E: Exception do begin Raise EInvalidDataBase.Create(EErroGeralBancoDeDados + #13#10 + E.Message); Result := False; end; end; finally S.Free; end; end; end else if Self is TConexaoFirebird then begin fClientDataSet := dmFirebird.ClUsuario; try fClientDataSet.Close; fClientDataSet.Open; fClientDataSet.Refresh; if not (fClientDataSet.state in dsEditModes) then fClientDataSet.Edit;

TBlobField(fClientDataSet.FieldByName(MyFieldName)).LoadFromFile(MyFile); fClientDataSet.Post; fClientDataSet.ApplyUpdates(0); except on E: Exception do begin Raise EInvalidDataBase.Create(EErroGeralBancoDeDados + #13#10 + E.Message); Result := False; end; end; end;end;

function TConexao.GetConexao(const typeConexao:

tBDConexao): TConexao;begin if Assigned(Result) then closeConexao;

case typeConexao of bdConexaoDBISAM: Result := TConexaoDBISAM.create; bdConexaoXML: Result := TConexaoXML.create; bdConexaoFirebird: Result := TConexaoFirebird.create; end;end;

Nós só precisamos também criar uma classe negocial – no nosso caso a classe de usuários TUsuario – que fará a “ponte” entre a camada de apre-sentação com ela, provendo por meio do encapsulamento funcionalidades básicas negociais disponíveis para os módulos de apresentação requeridos – não é interessante modularizar? Alterações em apenas um lugar – e todas as chamadas automaticamente atualizadas – abstração gera produtividade se bem empregada, como demonstra esta nossa construção.

Abrir um conjunto de dados (select) agora ficou mais simples de escre-ver - somente uma chamada de método (no caso, “AbreTabelaUsuarios”) é necessária. Evoluindo o processo, temos inúmeras vantagens:

Implementação da Orientação a Objetos: como citado acima, é a facilidade em reutilização de código em módulos, outros sistemas, etc;

Abstração realizada pelas classes de conexão: não é preciso (e nem deve) executar quaisquer comandos SQL ou acessar quaisquer base de dados diretamente na camada de apresentação;

Encapsulamento de DataSets: essa nossa infraestrutura padroni-zou a nomenclatura básica de execução de SQL´s, onde cada sentença é uma constante passada como parâmetro em um método de obter dataset do objeto TConexao. Logo abaixo segue um exemplo destacado deste item:

function TUsuario.AbreTabelaUsuarios: TDataSet;begin Result := Conexao.RetornaDataSet(sqlSelectAllFieldsOrderByNome);end;Abaixo é mostrado o método SetDataBase, onde é solicitada a troca de um banco. Note que o nome dos bancos fazem parte

julho201318

Código 06

de um tipo chamado tBDConexao, como citado acima, que é referenciado como um parâmetro constante:

type tBDConexao = (bdConexaoXML, bdConexaoDBISAM, bdConexaoFirebird);

procedure TForm1.cbSelecionaBDChange(Sender: TObject);begin case cbSelecionaBD.ItemIndex of 0: Usuario.SetDataBase(bdConexaoXML); 1: Usuario.SetDataBase(bdConexaoDBISAM); 2: Usuario.SetDataBase(bdConexaoFirebird); end; Usuario.CarregaUsuarios(ClUsuario); mskCarregaNomes.Text := ClUsuarioNome.AsString; mskCarregaNomesExit(Self);end;

Nossa classe TConexao também possui métodos de formatação específi-cos – nossos próprios FormatDate, FormatFloat, dentre outros. Isso porque o Firebird aceita o formato “yyyy-mm-dd” enquanto que o XML, por exemplo, aceita somente o formato “dd/mm/yyyy”. Já o FormatInteger formata o XML para o formato (com aspas simples) ‘meu número’ – enquanto que o Firebird aceita tanto o número puro (sem aspas) quanto com aspas simples. Já o banco DBISAM aceita o formato numérico somente sem aspas. Portanto, a classe fará o intercâmbio de formatos distintos de acordo com a instância apropriada.

Uma coisa interessante é o método GetNextId: ele tem a finalidade de recuperar o próximo valor de um código, por exemplo, para inseri-lo como uma chave-primária, ou apenas um valor normal, etc; são várias as possibilidades de utilização. Ele faz o select de um “Max(coluna)+1”, para retornar sempre o próximo item sequencial de um registro. Um detalhe especial é como o processo é feito para o nosso banco XML – ele faz um “Max” em um campo agregado de um TClientDataSet em criado em tempo de execução!

function TConexaoFirebird.GetNextId(const fFieldName: string; const fTable: string): string;

var fId: string; begin fId := TCustomSQLDataSet(Self.RetornaDataSet(Format(sqlMaxIndexFromFieldNameFormat1, [fFieldName, fTable]))).Fields[0].AsString; if (fId = ‘’) then fId := ‘1’; Result := fId; end;

Finalmente, o método CarregaUsuarios alimenta um objeto TClientData-Set de retorno, onde como já mencionado anteriormente armazenará dados apenas “read-only”: a aplicação jamais sensibilizará-los diretamente na base de dados. Todo este acesso somente a classe TConexao realizará e de forma abstrata. E isso é um dos pontos mais interessantes deste projeto: imagina trocar um banco de dados com sua aplicação rodando, ou enviá-la ao cliente em uma demonstração do produto com algumas funcionalidades disponíveis e na versão paga alterar o banco de dados para uma nova base de dados mais robusta e profissional; esta funcionalidade tornará sem dúvida sua aplicação isenta de implementações amarradas de dentro da camada de apresentação (método tradicional de programação), trazendo mais produtividade em termos de manutenção e desenvolvimento, e consequentemente mais agilidade e praticidade durante todo o ciclo de vida da aplicação.

Com isso, finaliza-se a primeira parte deste artigo. Na próxima revista falaremos sobre a implementação de um parser SQL para XML, utilização do componente de minha autoria para visualização e validação de dados, interagindo por “debaixo dos panos” – o TMaskeditHV (explicado em edições anteriores), explicação sobre importantes métodos da nossa classe e finalmen-te o desenvolvimento de nosso programa de exemplo utilizando esta nossa classe, em uma simulação real de sua implementação, obtendo e alternando bases de dados distintas em tempo de execução. Até a próxima, e boa leitura!

suporte@theclub.com.br

Hamden VogelAnalista de Sistemas pós-graduado em Engenharia de Software pela

UPIS e Programador Delphi com larga experiência desde 2000, tem de-senvolvido e vendido softwares em Delphi para a África e Estados Unidos, além do mercado nacional. Colaborou com dicas e componentes para sites especializados em Delphi. Também desenvolve em outras linguagens como C/C++, ASP, PHP e .NET.

Sobre o autor

julho2013 19

Um dos recursos mais poderosos e fascinantes no desenvol-vimento utilizando o sistema android é a possibilidade de poder interceptar eventos na tela com o toque do dedo, o “TouchScreen”. Temos classes específicas para este trabalho, a minha idéia neste mês é descrever as principais funciona-

lidades destas classes junto com seus métodos criando exemplos didáticos e de grande utilidade no dia-a-dia.

Eventos de Entrada (“Input Events”)

Existem várias maneiras de interceptar os eventos de interação do usuário com o aplicativo. Ao considerar eventos dentro de sua interface de usuário, a abordagem é capturar os eventos dentro da região denominada “View”, fornecendo os meios para fazê-lo. Quando compomos um layout, fazemos o uso de quantas “Views” forem necessárias, neste caso, podemos observar vários métodos de retorno de chamada pública que parecem úteis para os denominados eventos de InPut(entrada) e OutPut(saída). Esses métodos são chamados pelo Android quando a respectiva ação ocorre no objeto em ques-tão. Por exemplo, quando um componente (um botão) é tocado, o método “onTouchEvent()” é acionado no objeto. No entanto, a fim de interceptar isso, você deve estender a classe e substituir o método. No entanto, ampliando cada objeto “View”, a fim de lidar com um evento como esse não seria prático. É por isso que a classe “View” também contém uma coleção de interfaces aninhadas com retornos de chamada que poderemos utilizar com uma maior facilidade. Estas interfaces, chamadas de “Listeners” (“ouvintes”), são o seu “bilhete” para capturar a interação do usuário com a interface do aplicativo. Temos a possibilidade de estender uma classe “View”, a fim de construir por exemplo um componente personalizado. Outra situação é estender a classe “Button” para fazer algo mais sofisticado. Neste caso, poderemos definir os comportamentos de eventos padrão para sua classe usando os manipuladores de eventos, os (“Event Handlers”)

Manipuladores de Eventos (“Event Handlers”)

De acordo com a própria documentação do Android, quando estamos construindo um componente a partir da classe “View” teremos vários métodos

AndroidTrabalhando com o TouchScreen

para serem implementados, sendo:

onKeyDown (int, KeyEvent) - Chamado quando apertamos alguma tecla.onKeyUp (int, KeyEvent) - Chamado quando soltamos alguma tecla.onTrackballEvent (MotionEvent) - Chamado quando ocorre um evento

de movimento.onTouchEvent (MotionEvent) - Chamado quando ocorre um evento de

movimento da tela com o toque do dedo.onFocusChanged (boolean, int, Rect) - Chamado quando recebemos ou

perdemos o foco.

Demonstrei os métodos acima a fim de apresentar os manipuladores existentes. Daremos importância ao evento “OnTouchEvent”.

Entendendo a classe “MotionEvent”

A classe base para suporte TouchScreen é a classe “MotionEvent” onde é passado para as “Views” através do método onTouchEvent () (abordado anteriormente) podendo também ser sobrecarregado . Vejamos na Imagem 01 a hierarquia desta classe para maiores informações.

Figura 01: Estrutura da classe “MotionEvent”.A classe “MotionEvent” contém inúmeros métodos e constantes como

julho201320

Código 01

por exemplo: informações das coordenadas X, Y e capturas de movimentos.

Principais métodos e constantes

- GetAction(): Este método recebe a ação que foi executada, fornecendo as seguintes constantes para determinar a ação.

ACTION_DOWN: Ação que ocorre quando um toque foi iniciado contendo o local de partida inicial do movimento.

ACTION_UP: Esta constante é acionada quando um gesto pressionado tenha terminado, contendo a localização final, bem como todos os pontos intermediários desde o último movimento.

ACTION_MOVE: Ação que ocorre entre as constantes ACTION_DOWN e ACTION_UP. (A movimentação em si)

Todas as constantes abordadas acima retornam um valor inteiro.- GetY(): Este método retorna um valor do tipo “Float” das coordenadas

“Y” (linha vertical). Este valor pode ser transformado para inteiro.- GetX():Este método retorna um valor do tipo “Float” das coordenadas

“X” (Linha horizontal). Este valor pode ser transformado para inteiro.

Exemplo 1 - Movimentando uma Imagem com o toque do dedo

Nos exemplos deste artigo iremos envolver todos os conceitos aprendidos anteriormente sendo que neste primeiro criaremos uma imagem dinamica-mente. Esta imagem será movimentada com o dedo e usando o “TouchScreen” na tela do dispositivo. Para isto descreverei todos os passos daqui pra frente.

Inicie uma aplicação do Zero clicando em “File/New/Android Project...” criando uma classe para estender (extends) para a interface “View”. Clique sobre o pacote e com o botão direito escolha “New/Class”. É nesta classe onde criaremos todos os métodos responsáveis pela movimentação da Imagem em questão. Ver Figura 02.

Figura 02: Criando a classe “CriarImagem.java”.

Como foi discutido anteriormente, devemos utilizar a classe “View” para implementarmos o método OnTouchEvent().

Classe “CriarImagem.java”

Antes de iniciarmos a codificação desta classe será necessário adicionar uma imagem qualquer em nosso aplicativo. Basta copiar e colar no diretório “res/drawable-hdpi”. Ver Imagem 03.

Figura 03: Imagem adicionada no projeto.

Observação Importante:

Esta imagem deverá ser do tipo “.png” ou “jpg” possuindo o nome escrito especificamente em caixa baixa para assim evitar problemas de compilação.

Logo em seguida importaremos as bibliotecas que serão utilizadas ao decorrer do desenvolvimento.

package pct.Android_OnTouchEvent;

import android.content.Context;import android.graphics.Canvas;import android.graphics.drawable.Drawable;import android.util.AttributeSet;import android.view.MotionEvent;

julho2013 21

Código 02

Código 03

Código 04

import android.view.View;public class CriarImagem extends View{ private Drawable imagem; private int x, y, largura, altura; private boolean Clicou; public int movimento = 12;

A classe principal “CriarImagem” herdará da classe “View”. Utilizaremos algumas variáveis privadas, sendo uma do tipo “Drawable” responsável por trabalhar com a imagem, outras do tipo “int” onde definimos a largura, altura, as coordenadas X, Y e uma booleana indicando se clicamos ou não na imagem.

public CriarImagem(Context context, AttributeSet attrs) { super(context, attrs);imagem = context.getResources().getDrawable(R.drawable.theclub); largura = imagem.getIntrinsicWidth(); altura = imagem.getIntrinsicHeight(); x = 150; y = 300; setFocusable(true);}

No método Construtor passamos dois parâmetros: o “Context” o Contexto da aplicação e o “AttributeSet” que significa uma coleção de atributos que po-dem ser utilizados dentro deste método. O método “context.getResources().getDrawable()” irá recuperar a imagem, os métodos “getIntrinsicWidth()” e “getIntrinsicHeight()” irão retornar a largura e altura respectivamente, x e y serão as coordenadas para posicionamento da imagem em relação a tela do dispositivo. Já o método “setFocusable()” definirá se a “view” irá ou não receber o foco enquanto estiver em modo “TouchScreen”. Deixaremos como “true”

@Overrideprotected void onDraw(Canvas canvas) { super.onDraw(canvas); imagem.setBounds(x,y,x+largura,y+altura); imagem.draw(canvas);}

Para desenhar a imagem foi necessário reescrever o método “OnDraw()” tendo como parâmetro a classe “Canvas”. Passamos as coordenadas X e Y e a largura e altura utilizando o método “setBounds()” e redesenhamos com o “draw()” usando a classe “Canvas”. Este método é disparado sempre quando necessitamos redesenhar a imagem.

public boolean onTouchEvent(MotionEvent motionEvent){ this.x = (int)motionEvent.getX(); this.y = (int) motionEvent.getY(); switch(motionEvent.getAction()) { case MotionEvent.ACTION_DOWN: { Clicou = imagem.copyBounds().contains(x,y); break; } case MotionEvent.ACTION_MOVE: if (Clicou) { this.x = x - (largura/2); this.y = y - (altura/2); break; } case MotionEvent.ACTION_UP : { Clicou = false; break; } } invalidate(); return true;}

Este é o principal evento que iremos trabalhar. Ele tem como parâmetro de entrada a classe “MotionEvent” e retorna um valor booleano. No primeiro momento iremos atribuir às variáveis globais X e Y as respectivas coordena-das com os métodos “getX()” e “getY()”. Faremos um “Case” para comparar

julho201322

Código 04

as Constantes do método “GetAction()”, o mesmo que recebe a ação que foi executada, fornecendo constantes para determinar a ação. Na constante “ACTION_DOWN” com o método “copyBounds()” indicamos que clicamos na imagem informando suas coordenadas. A constante “ACTION_MOVE”, faz o ato de mover em si, movimentamos a figura fazendo o cálculo das coordenadas menos o tamanho dividido por dois, dando uma impressão de movimento. Por final retiramos o foco com a constante “ACTION_UP”. Resumindo, este método irá movimentar a Imagem conforme o toque do dedo.

Configurações no “AndroidManifest.xml”

Nas configurações do arquivo “AndroidManifest.xml” não faremos praticamente nada de mirabolante, apenas setamos o uso da “Activity” “Android_OnTouchEventActivity” que será comentado logo a seguir. Ver em seguida a listagem completa.

<?xml version=”1.0” encoding=”utf-8”?><manifest xmlns:android=”http://schemas.android.com/apk/res/android” package=”pct.Android_OnTouchEvent” android:versionCode=”1” android:versionName=”1.0”> <uses-sdk android:minSdkVersion=”8” />

<application android:icon=”@drawable/icon” android:label=”@string/app_name”> <activity android:name=”.Android_OnTouchEventActivity” 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>Configurações no “Strings.xml”Este arquivo irá definir algumas constantes que serão abordadas ao decorrer do projeto, como

por exemplo: a cor cinza que preencherá o fundo onde movimentaremos a imagem. Ver código abaixo:.

<?xml version=”1.0” encoding=”utf-8”?><resources> <string name=”hello”>Trabalhando com o evento OnTouchEvent!</string> <string name=”app_name”>The Club - Android</string> <color name=”cinza”>#D0D0D0</color></resources>

Criando o “Lay-Out”

O aplicativo possuirá um “LinearLayout” onde conterá um “TextView” e um componente chamado desenho que faz referência à classe “CriarImagem”. Ver Imagem 04.

Figura 04: Componentes utilizados.

A Imagem 05 nos dá uma noção do Lay-out.

Figura 05: Lay-Out do exemplo 1.

julho2013 23

Código 05

Código 06O XML correspondente:

<?xml version=”1.0” encoding=”utf-8”?><LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android” android:orientation=”vertical” android:layout_width=”fill_parent” android:layout_height=”fill_parent” ><TextView android:layout_width=”fill_parent” android:layout_height=”wrap_content” android:text=”@string/hello” /><pct.Android_OnTouchEvent.CriarImagem android:id=”@+id/desenho” android:layout_width=”fill_parent” android:layout_height=”fill_parent” android:background=”@color/cinza” /> </LinearLayout>

Devemos dar uma atenção especial na linha de código abaixo:

<pct.Android_OnTouchEvent.CriarImagem />

Percebam que interessante, conseguimos chamar diretamente uma classe (no caso uma “View”) de dentro do XML, é fantástico!

Codificando o exemplo 1

Seguindo a lógica, a atividade “Android_OnTouchEventActivity” que codificaremos a seguir, possuirá uma chamada para o lay-out “criarimagem.xml” que dentro do mesmo teremos a classe “CriarImagem.java”, na qual está localizada toda a codificação de nosso exemplo.

package pct.Android_OnTouchEvent;

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

public class Android_OnTouchEventActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.criarimagem); } }

O “SetContentView()” será o método que irá chamar a tela de nosso aplicativo. Ver Imagem 06.

Exemplo em “Run-Time”

Figura 06: Movimentando a Imagem “The Club”.

Exemplo 2 – Pintando e escrevendo na Tela com o toque do dedo

Este segundo exemplo irá pintar e desenhar na tela de nosso aplicativo com o toque do dedo. Aprenderemos também a trabalhar com a classe “Paint”,

julho201324

Código 07

Código 08

Código 09

Código 10

Código 11

“Path” entre outras. Os passos são idênticos ao do exemplo anterior, por isto detalharei um pouco menos para ficar menos cansativo abordando apenas os conceitos inéditos.

Chega de conversa e vamos ao trabalho!

Classe “PintarTela.java”

Utilizaremos algumas bibliotecas adicionais para desenvolver este exem-plo, veja abaixo:

package pct.Android_OnTouchEvent;import android.content.Context;import android.graphics.Canvas;import android.graphics.Color;import android.graphics.Paint;import android.graphics.Path;import android.util.AttributeSet;import android.view.MotionEvent;import android.view.View;

Temos a classe “android.graphics.Paint” sendo específica para pintura, estilo, cor. Ela também oferece base para desenhar geometrias, texto e bit-maps. Já a classe “android.graphics.Path” permite realizar contornos e formas geométricas como: segmentos de linhas retas, curvas quadráticas e cúbicas.

public class PintarTela extends View { private Paint paint = new Paint(); private Path path = new Path();

Esta classe também herdará da classe “View” e utilizará dois objetos, do tipo “Paint” e “Path”.

public PintarTela(Context context, AttributeSet attrs) { super(context, attrs);

paint.setAntiAlias(true);

paint.setStrokeWidth(6); paint.setColor(Color.BLUE); paint.setStyle(Paint.Style.STROKE); paint.setStrokeJoin(Paint.Join.ROUND); }

Temos o método “setAntiAlias()” que serve para suavizar as bordas de nosso toque, o “setStrokeWidh()” é o tamanho da linha, o “setColor()” para definir a cor, o “setStyle()” o estilo e o “setStrokeJoin()” é um tratamento específico para quando as linhas se juntarem.

@Override protected void onDraw(Canvas canvas) { canvas.drawPath(path, paint); }

Método que irá desenhar usando as configurações definidas anteriormente na classe “Paint”.

@Override public boolean onTouchEvent(MotionEvent motionEvent) { float eventX = motionEvent.getX(); float eventY = motionEvent.getY();

switch (motionEvent.getAction()) { case MotionEvent.ACTION_DOWN: path.moveTo(eventX, eventY); return true; case MotionEvent.ACTION_MOVE: path.lineTo(eventX, eventY); break; default: return false; }

julho2013 25

Código 12

Código 13

Código 14

invalidate(); return true; }

Usaremos apenas as constantes “ACTON_DOWN” para dar início do mo-vimento de acordo com as coordenadas definidas fazendo o uso do método “MoveTo()” e a “ACTION_MOVE”para adicionar uma linha a partir do último ponto especificado pelas coordenadas (x, y).

Configurações no “AndroidManifest.xml”

Adicionaremos algumas configurações básicas neste arquivo já comentado mais acima, veja o trecho:

...<activity android:name=”.Android_OnTouchEventActivity_2” android:label=”@string/app_name”> <intent-filter> <action android:name=”android.intent.action.MAIN” /> <category android:name=”android.intent.category.LAUNCHER” /> </intent-filter> </activity>...

Criando o “Lay-Out”

Teremos um “LinearLayout” onde conterá um “TextView” e um componen-te chamado desenho que faz referência à classe “Pintartela”. Ver Imagem 07.

Figura 07: Lay-Out do exemplo 2.

O XML correspondente:

<?xml version=”1.0” encoding=”utf-8”?><LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android” android:orientation=”vertical” android:layout_width=”fill_parent” android:layout_height=”fill_parent” ><TextView android:layout_width=”fill_parent” android:layout_height=”wrap_content” android:text=”@string/hello” /> <pct.Android_OnTouchEvent.PintarTela android:id=”@+id/desenho” android:layout_width=”fill_parent” android:layout_height=”fill_parent” /> </LinearLayout>

Codificando o Exemplo 2

Seguindo os passos que já foram descritos acima foi necessário criar uma classe estendendo de uma “Activity” para invocarmos o XML contendo a classe “PintarTela”. O método “SetContentView()” irá chamar a tela de nosso aplicativo. Ver Imagem 08.

Abaixo código completo.

package pct.Android_OnTouchEvent;import android.app.Activity;import android.os.Bundle;

public class Android_OnTouchEventActivity_2 extends Activity { @Override public void onCreate(Bundle savedInstanceState)

julho201326

thiago@theclub.com.br

Thiago Cavalheiro Montebugnoliadora aprender novas tecnologias. Formado pela Faculdade de Tecnologia de Botucatu

– SP (FATEC), já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco de Dados SQL Server e Firebird. Atualmente trabalha no Centro de Processamento de Dados da Prefeitura Municipal de Itaí-SP é colunista mensal da Revista The Club Megazine e é consultor Técnico do The Club. Possui as seguintes certificações: MCP - Microsoft Certified Professional, MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer e MCSD - Microsoft Certified Solution Developer.

Sobre o autor

{ super.onCreate(savedInstanceState); setContentView(R.layout.pintartela); }}

Exemplo em “Run-Time”

Figura 08: Desenhando e Pintando em “Run-Time”.

Referênciashttp://developer.android.com/reference/android/view/MotionEvent.htmlhttp://developer.android.com/reference/android/view/View.html

Conclusões

Uma das formas de interceptar os eventos de interação do usuário com o aplicativo é capturar estes eventos dentro de uma região chamada “View”. É a partir desta classe que discorremos o artigo deste mês. Trabalhamos com o evento “OnTouchEvent()”, que é o evento que capta o toque do dedo na tela do dispositivo e a classe “MotionEvent”, classe base para suporte para esta tarefa junto com métodos e constantes. No primeiro exemplo procurei demonstrar como movimentar uma imagem com o “TouchScreen”, já no segundo como pintar e escrever na tela do aplicativo. Esta é uma das inúmeras formas de usar os recursos “TouchScreen” na programação Android.

Espero que tenham gostado! Deixo aqui um abraço e nos vemos no mês que vem!

julho2013 27

Código 01

O Delphi XE4 já está disponível para download, e conta com várias novidades que lhes apresentarei neste artigo.

A primeira delas, está na exclusão da RAD Studio que na versão anterior trazia quatro IDEs que podíamos utilizar para desenvolver o Delphi, C++, PHP e .NET. No XE4

o Delphi XE4 Prism. Com isso a RAD Studio irá ficar com Delphi, C++Builder e HTML5 Builder.

Entre as principais mudanças no Delphi XE4, estão:

• Desenvolvimento de aplicações multidispositivos para iOS, Windows e Mac.

• Desenvolvimento de aplicações para iPhone e iPad.• Controles de interface do iOS.• Rápida criação de protótipos.• Suporte aos bancos de dados IBLite e SQLite iOS.• Suporte à cliente multicamadas para DataSnap, web services e

bancos de dados corporativos.• Acesso a mais bancos de dados em mais dispositivos e com maior

facilidade na FireDAC.• Plataforma de Aplicações FireMonkey FM3.

Explicarei então, rapidamente cada um destes novos recursos.

Desenvolvimento de aplicações multidispositivos para iOS, Windows e Mac.

As vantagens de desenvolver aplicações multidispositivos, significa que não precisaremos manter projetos de desenvolvimento separados para criar uma aplicação de modo nativo em múltiplas plataformas (iOS, Windows e Mac).

O desenvolvimento de aplicações verdadeiramente nativas permite que criemos aplicações nativas livres de scripts, que tiram o máximo proveito das capacidades e desempenho dos dispositivos subjacentes. Resultando em aplicações mais rápidas e ricas que agradarão ainda mais seus usuários finais.

As principais mudanças Delphi XE4

Aplicações para iPhone e iPad e os controles de interface do iOS.

Agora podemos desenvolver aplicações usando um componente de calen-dário para escolhermos uma data em um aplicativo iOS como mostra a figura 01.

Figura 01: Adicionando o componente TcalendarEdit

Selecionando o componente TcalendarEdit, no Object Inspector, abrire-mos a aba Events clicando duas vezes no espaço vazio ao lado de onchange. Escreveremos o código da seguinte forma:

procedure TForm25.CalendarEdit1Change(Sender: TObject);begin ShowMessage(FormatDateTime(‘dddddd’, CalendarEdit1.Date));end;

Podemos também usar um componente de botão com estilos diferentes em um aplicativo iOS como mostra a figura 02.

julho201328

Figura 02: Estilos do botão.

Usando componentes combobox para escolher itens de uma lista em um aplicativo iOS como mostra a figura 03.

Figura 03: Adicionando ComboBox na aplicação

Depois de adicioná-lo, podemos observar o componente ComboBox no form, clicando com o botão direito do mouse no componente ComboBox e selecionando itens do editor, abri-rá uma janela como mostra a figura 04.

Figura 04: Adicionando itens no ComboBox.

Essa ferramenta conta com diversos recursos, porém, não entraremos em detalhes neste artigo.

Agora veremos como usar o componente TWebBrowser em um aplicativo iOS.

Utilizaremos os seguintes componentes:

TToolBarTButtonTEdit

A aplicação vai ficar como a figura 05:

Figura 05: Componentes adicionados.

julho2013 29

Código 02

Código 03

Código 04

Antes de implementar manipuladores de eventos, primeiramente im-plantaremos um método comum para abrir uma página web com base na propriedade Text do Tedit.

procedure OpenURL; next to { Private declarations } type Tform34 = class(TForm) ToolBar1: TToolBar; Button1: TButton; Edit1: TEdit; WebBrowser1: TwebBrowser; private Procedure OpenURL; Publicend;

Aperte CTRL + SHIFT + C para criar o procedimento.

Procedure TForm34.OpenURL;BeginWebBrowser1.Navigate(Edit1.Text);end;

A linha “WebBrowser1.Navigate(Edit1.text); “ iremos programar conforme o nome componente.

No evento OnChange do edit digite OpenURL;

E no evento KeyDown do edit digite o seguinte código.

Procedure Tform34.Edit1KeyDown(Sender; bar Key: Word;var KeyChar: char; Shift: TshiftState);BeginIf (key = vkReturn) thenBeginOpenURL;Button1.SetFocus;end;end;

Pronto agora é só testar e usar a criatividade para melhorar a interface da aplicação.

Rápida criação de protótipos

O Delphi XE4 fornece um fluxo de trabalho aperfeiçoado e otimizado, que automatiza a distribuição e a depuração tanto no simulador quanto no dispositivo. Crie com rapidez protótipos de suas aplicações com layouts para cada tipo de dispositivo, passando com agilidade da prototipagem à produção. Integre o feedback rapidamente, distribuindo seu protótipo diretamente no dispositivo de destino, usando objetos e códigos reais do framework.

Suporte aos bancos de dados IBLite e SQLite iOS

O Delphi XE4 inclui suporte a banco de dados iOS local para SQLite e Inter-Base embutido via dbExpress, FireDAC e IBX. Você ainda recebe uma licença de distribuição gratuita e ilimitada do IBLite para iOS

Suporte a cliente multicamadas para DataSnap, web services e bancos de dados corporativos

O Delphi XE4 inclui conectividade integrada a banco de dados de classe corporativa ou ISV, computação nas nuvens e middleware. Você conta com suporte integrado a SQL Server, Oracle, Sybase, DB2, InterBase, SQL Anywhere, SQLite, MySQL e muitos outros bancos de dados embutidos e de servidor, assim como serviços nas nuvens, incluindo Windows Azure e Amazon.

Acesse mais bancos de dados em mais dispositivos e com maior facilidade com a FireDAC

A FireDAC dá a você acesso direto, nativo e de alta velocidade do Delphi a InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, DB2, SQL Anywhere, Advantage DB, Firebird, Access, Informix, DataSnap e muitos outros bancos de dados mobile e corporativos, locais ou embutidos. Migre com facilidade do BDE e de outras tecnologias.

Plataforma de Aplicações FireMonkey FM3

O Delphi XE4 tira máximo proveito do FireMonkey® FM3, a plataforma de última geração para construção de aplicações multidispositivos verda-deiramente nativas a partir de uma única base de código. Você codifica uma única vez e o framework aperfeiçoa sua aplicação para múltiplas plataformas de destino. Componentes visuais dão a você blocos de construção extensíveis e reutilizáveis para que se obtenha um desenvolvimento mais rápido e alta-mente manutenível.

Novo Compilador

Para oferecer suporte aos dispositivos móveis foram criados dois novos compiladores, um para o simulador do iOS e outro para o dispositivo físico (ARM), já que as arquiteturas são distintas.Desta forma agora temos:

• Win32 compiler (DCC32)• Win64 compiler (DCC64)• Mac compiler (DCCOSX)• iOS Simulator compiler (DCCIOS32)• iOS ARM compiler (DCCIOSARM)

A novidade está nos dois últimos, os quais seguem um desenho totalmente novo, baseados em um padrão chamado LLVM (http://llvm.org). Podemos

julho201330

Código 05

entender o LLVM como um conjunto de módulos e ferramentas reutilizáveis para compiladores, utilizados amplamente por diversos compiladores nativos, entre eles o próprio Xcode, nativo da Apple.

Mudanças no Delphi Language

Para suportar dispositivos móveis, o novo compilador impõe algumas mudanças de linguagem. Na verdade, mais do que mudanças, trata-se de uma grande evolução da linguagem Delphi. No futuro, estes e outros avanços serão portados também para os compiladores Win32, Win64 e OSX.

Automatic Reference Counting (ARC)

O ARC traz o melhor dos dois mundos: gerenciamento automático de memória sem a necessidade de um garbage collection, tido como um grande vilão de performance nas linguagem que o utilizam. Em resumo o ARC gerencia o ciclo de vida de objetos sem que você tenha que se preocupar com o “Free”.

Class procedure TMySimpleClass.CreateOnly;VarMyObj: TMySimpleClass;BeginMyObj := TMySimpleClass.Create;MyObj.DoSomething;End;

No exemplo acima, o objeto MyObj será removido da memória assim que sair do escopo. Importante ressaltar que a sintaxe tradicional (try/finally fazendo o Free manual do objeto) continua suportada, portanto as migrações de código estão garantidas.

Também está disponível o pattern Dispose e suporte a [Weak] References. Você pode encontrar mais sobre isso aqui: http://edn.embarcadero.com/article/43073.

Tipo String

Todos os tipos string existentes (AnsiString, UTF8String, RawByteString, WideString, AnsiChar, PAnsiChar, PWideChar, OpenString, ShortString) agora estão simplificados em um único: String. Além disso, as strings agora são 0-based ao invés de 1-based. Isso significa que alguns códigos podem precisar de revisão, mas as funções de manipulação de strings já estão preparadas para esta mudança.

Outra importante mudança é que as strings passarão a ser “imutáveis”, devido ao gerenciamento de memória dos dispositivos móveis. Nesta versão do compilador tudo continua conforme anteriormente, você receberá apenas uma warning alertando que, futuramente, construções como a exibida abaixo não será mais suportada:

str1[3]:=’w’;

Portanto é altamente recomendado que, para seus novos códigos, você

faça uso de construções como TStringBuilder e TStringHelper para a manipu-lação de strings. Um trecho de código utilizando estas classes para ilustrar:

Outras mudanças

1. Ponteiros não são suportados no mundo mobile2. Não há suporte para Inline assemby3. Evite chamadas a APIs diretamente, esteja pronto para as novas

plataformas que virão.4. Prefira utilizar as units cross-plataform, especialmente ao manipular

arquivos (unit IOUtils)Informações e recursos para pesquisa5. Páginas principais dos produtos: RAD Studio, Delphi, C++ Builder,

HTML5 Builder6. Documentação on line: http://docwiki.embarcadero.com/RADStu-

dio/XE4/en7. Tutorial Delphi para iOS: Delphi iOS Application Development8. Link para download do trial: https://downloads.embarcadero.com/

free/rad-studio9. Trial via Instant Trial (AppWave): http://windowsapps.com/rad-

-studio-trial.html?trial=110. Tudo o que há de novo no Delphi e C++ Builder XE411. O que há de novo especificamente no C++ Builder 64 bit12. Lista de correções do Delphi e C++ Builder XE4: http://edn.embar-

cadero.com/article/4306813. White Paper do Marco Cantu sobre todas as mudanças na lingua-

gem: http://www.embarcadero.com/resources/white-papers/application--development

Conclusão

Espero que tenham gostado do artigo, resumi as principais alterações que foram feita no Delphi XE4 que considero importante.

Até a próxima.

zeca@datasmart.com.br

José Antônio P. M. de PaulaConsultor Técnico no The Club. Cursa o último período da FATEC

(Botucatu) no curso de Informática para Negócios.

Sobre o autor

julho2013 05

julho2013