Balaio Tecnológico

Estruturas de Dados com Delphi - parte II : Pilhas

2013-04-22T10:40:00.002-03:00

No meu último post, comecei a falar sobre estruturas de dados e como o Delphi lida com as estruturas mais comuns, como as filas. Neste post, eu mostro o conceito de outra das estruturas padronizadas que o Delphi trata de forma inerente : pilhas.

A diferença central entre filas e pilhas está na ordem em que os elementos são retirados da estrutura. No caso das filas, o primeiro elemento inserido será o primeiro a ser retirado, mecanismo conhecido como FIFO (First In, First Out). Para as pilhas, o último elemento inserido é retirado primeiro; isto é, pilhas implementam o LIFO (Last In, First Out). Para compreender esse conceito, imagine que você guarde os pratos de sua casa empilhados no armário. Sempre que você precisa de um prato, retira o que está no topo da pilha. Quando vai guardá-los, os pratos são postos no topo da pilha novamente, disponíveis para o próximo uso.

Uma situação computacional prática onde o uso de pilhas se adequa é o cálculo do custo de um produto fabricado. Por exemplo, para calcular o custo de fabricação de um computador, temos que calcular o custo da CPU, do monitor e do teclado. No entanto, obter o custo da CPU requer que se calcule antes o custo da placa-mãe, transistores, capacitores, etc. A placa-mãe também é composta por outros itens, e assim sucessivamente.

Nessa estrutura, podemos somar o custo individual de cada componente até encontrar um que também seja composto. O item composto é incluído no topo da pilha enquanto se calcula seu custo. Tal processo deve ser feito recursivamente até que haja apenas itens simples. Nesse momento, o custo do último item adicionado à pilha está determinado e ele pode ser removido da pilha, prosseguindo o cálculo com o item seguinte.

Para implementarmos com as classes nativas do Delphi uma solução para essa situação, considere as classes abaixo:

  TWProduto = class

  public

    Codigo: String;

    Custo : Double;

    Componentes: TList;

    Constructor Create(ACodigo:String;ACusto: Double);

    Destructor Destroy;override;

  End;

  TWContexto=class

  public

    produto: TWProduto;

    indice : integer;

    custo  : double;

    Constructor Create(AProduto: TWProduto);

  end;

{ ... }

Constructor TWProduto.Create(ACodigo:String;ACusto: Double);

begin

  Codigo := ACodigo;

  Custo  := ACusto;

  Componentes:= TList.Create;

end;

Destructor TWProduto.Destroy;

begin

  { ... }

  Componentes.Free;

  inherited;

end;

Constructor TWContexto.Create(AProduto: TWProduto);

begin

  produto := AProduto;

  indice := 0;   { iniciar cálculo nesse índice }

  custo  := 0.0; { custo inicial do produto }

end;

A primeira classe (TWProduto) representa um produto que pode ser composto de outros produtos, incluindo outros produtos compostos. Já a classe TWContexto serve para controlar o cálculo do custo de um único produto composto. Além do próprio produto, ela armazena o índice do último componente considerado pelos cálculos bem como o custo obtido até o momento.

No quadro a seguir, eu simulo manualmente a montagem simplificada de um computador. O resultado é um exemplo de estruturação complexa usando a classe de produto descrita acima e cujo custo poderá ser calculado com uma rotina usando pilha:

function TForm1.MontaComputador : TWProduto;

var computador, compon, subcompon: TWProduto;

begin

  computador := TWProduto.Create('Computador', 0.0);

  compon := TWProduto.Create('Teclado', 20.0);

  computador.Componentes.Add(compon);

  compon := TWProduto.Create('Monitor', 235.0);

  computador.Componentes.Add(compon);

  { A CPU é um produto composto }

  compon := TWProduto.Create('CPU', 0.0);

  subcompon := TWProduto.Create('Placa-mãe', 250.0);

  compon.Componentes.Add(subcompon);

  subcompon := TWProduto.Create('Cooler', 32.0);

  compon.Componentes.Add(subcompon);

  computador.Componentes.Add(compon);

  Result := Computador;

end;

A rotina abaixo usa pilha para controlar o cálculo do custo de um produto - no caso, o computador estruturado no quadro anterior. Em Delphi, a classe TStack implementa as operações necessárias para se trabalhar com uma pilha.

procedure TForm1.btnCalcularCustoClick(Sender: TObject);

var i : integer;

    interromper : boolean;

    Pilha: TStack;

    contexto, ctxAux : TWContexto;

    computador : TWProduto;

begin

  computador := MontaComputador;

  contexto := TWContexto.Create (computador);

  { Inicia a pilha com o produto original no contexto : o computador }

  Pilha:= TStack.Create;

  Pilha.Push(contexto);

  while (pilha.Count > 0) do begin

    { Obtém o contexto no topo, sem removê-lo }

    contexto := pilha.Peek;

    compon := contexto.produto;

    i := contexto.indice;

    { Percorre os componentes desse produto, somando o custo de cada um para obter o custo do total do produto em si }

    interromper := false;

    while (i < compon.Componentes.Count) And (not interromper) do begin

      subcompon := compon.Componentes.Items[i];

      { Esse produto é composto ? }

      interromper := (subcompon.Componentes.Count > 0);

      if (interromper) then begin

        { Inclui o subcomponente composto no topo da pilha pra calcular seu custo }

        ctxAux := TWContexto.Create (subcompon);

        Pilha.Push(ctxAux);

        { Quando desempilhar esse produto, inicie no componente seguinte }

        contexto.indice := i + 1;

      end

      else

        contexto.custo := contexto.custo + subcompon.Custo;

      Inc (i);

    end;

    { Conseguiu totalizar o custo do produto; então, remove-o do topo da pilha }

    if not interromper then begin

      Pilha.Pop;

      compon.Custo := contexto.custo;

      contexto.Free;

      { Adiciona o custo calculado ao custo do produto do qual esse componente é parte }

      if pilha.Count > 0 then begin

        contexto := pilha.Peek;

        contexto.custo := contexto.custo + compon.Custo;

      end;

    end;

  end;

  { Apresenta o custo obtido }

  lblCusto.Caption := FormatFloat ('#,##0.00', computador.Custo);

  Pilha.Free;

  computador.Free;

end;

Assim como no caso da fila tratado no outro post, o constructor da pilha exige a especificação do tipo de dado com o qual a pilha será capaz de trabalhar. No exemnplo, a classe TWContexto é informada para que possamos controlar os produtos que já foram considerados no cálculo do custo.

As funções mais importantes na pilha são a que acrescenta e a que remove um elemento. Para inserir um novo elemento no topo da pilha, use o método Push e para extraí-lo use Pop, como mostrado no código acima.

É possível ainda obter o elemento que está no topo da pilha sem, no entanto, extraí-lo. Para isso, há o método Peek, também utilizado no exemplo.

Embora não tenha sido necessário aqui, o TStack permite interceptar a adição e remoção de elementos através do evento OnNotify. Ele é frequentemente utilizado para liberar a memória associada aos elementos da pilha.

Mais Informações
Estruturas de Dados com Delphi - parte I : Filas, Estruturas de Dados no Wikipedia, Pilhas

Estruturas de Dados com Delphi - parte I : Filas

2013-03-26T11:54:00.001-03:00

Em maior ou menor grau, o trabalho de um programador de computadores envolve lidar com meios de organizar os dados internos de seus programas. Uma organização bem planejada é imprescindível para a implementação de algorítmos eficientes, o que afeta tanto a performance da aplicação quanto sua facilidade de manutenção. As formas de se organizar os dados em um programa são chamadas de Estruturas de Dados.

Pela sua importância, a maioria das linguagens de programação oferecem bibliotecas com implementações genéricas pré fabricadas para as formas tradicionais de organização de dados, tais como listas, pilhas e filas. No caso do Delphi, esses e outros mecanismos estão disponíveis na unit System.Generics.Collections. Neste post, começo a mostrar as principais estruturas existentes nessa biblioteca, complementando a explicação com exemplos práticos em Delphi.

Em primeiro lugar, precisamos compreender como funciona cada uma das estruturas para podermos decidir qual a mais apropriada para cada situação.

Por exemplo, as filas são desenhadas para o cenário onde precisamos tratar uma sequência de valores exatamente na mesma ordem em que esses valores vão surgindo. É o conceito da fila do caixa em uma loja: cada cliente é atendido sequencialmente de acordo com sua posição na fila; novos clientes entram no final da fila para serem atendidos. Em programação, esse conceito pode ser aplicado ao tratamento de requisições enviadas para execução num sistema. O quadro abaixo traz a declaração básica de uma classe Delphi representando uma requisição executável:

  TWRequis = class

  public

    procedure Execute;virtual;abstract;

    function Terminou : Boolean;virtual;abstract;

  End;

As Collecions definidas pelo Delphi são estruturas de dados genéricas, mais ou menos como as STL do C++. Isso significa que, quando declaramos uma instância dessas estruturas, devemos informar o tipo de dado que essa Collection em particular vai tratar. Para deixar mais claro, veja a declaração da classe que controlará a execução de requisições em nosso exemplo de fila:

  TWVerifRequis = class

   { ... }

  public

    Fila: TQueue<TWRequis>;

    procedure DoOnNotify (Sender: TObject; const Item: TWRequis; Action: TCollectionNotification);

    constructor Create;

    destructor Destroy;override;

    procedure InsereRequis(ATipo: integer);

    procedure Start;

  end;

No exemplo, declarei a fila associada à classe de requisição. Se for necessário, também é permitido associar a tipos atômicos (como integer e string) ou a estruturas (record). Agora, vamos dar uma olhada no construtor da classe:

constructor TWVerifRequis.Create;

begin

  Fila := TQueue<TWRequis>.Create();

  Fila.OnNotify := DoOnNotify;

end;

Veja que também ao criar uma instância da fila (o TQueue) devemos especificar o tipo de dado com o qual ela está apta a trabalhar. Um outro detalhe é o evento OnNotify; interceptá-lo nos permite reagir a alterações na fila, tais como saber que um novo registro foi incluído ou acabou de ser removido. Em ambos os casos, podemos atualizar o status da fila para o usuário, avisando-o quantos registros restam e qual requisição está sendo processada. Repare ainda que a assinatura do evento reflete o tipo de dado que nossa fila trata, restringindo a resposta do OnNotify a este tipo específico:

procedure TWVerifRequis.DoOnNotify (Sender: TObject;const Item: TWRequis; Action: TCollectionNotification);

begin

  { A requisição que está no início da fila foi removida; então, ela deve ser executada }

  if Action = cnRemoved then begin

    { Atualiza o status, notificando o usuário sobre que requisição está em processamento }

    NotificaRequisAtual(Item);

    Item.Execute;

    Item.Free;

  end;

  { Atualiza o status, notificando o usuário sobre quantas requisições restam na fila p/ executar }

  NotificaQtd (Fila.Count);

end;

As funções mais importantes para essa estrutura de dado são a que acrescenta e a que remove um elemento da fila. Para incluir um novo item ao fim da fila, use o método Enqueue e para remover o elemento que está no início da fila, use Dequeue, como mostra o exemplo a seguir:

procedure TWVerifRequis.InsereRequis(ATipo: integer);

var lRequis : TWRequis;

begin

  { Invoca a factory para criar a requisição correta de acordo com o tipo informado }

  lRequis := CriaNovaRequisicao(ATipo);

  { Acrescenta ao fim da lista a nova requsição criada }

  Fila.Enqueue(lRequis);

end;

procedure TWVerifRequis.Start;

var lRequis : TWRequis;

begin

  { Enquanto não foi solicitado o término da execução, continua monitorando a fila }

  while Not Terminou() do begin

    { Se há elemento na lista, remove-o aqui. Isso dispara o evento OnNotify, permitindo a execução dessa requisição }

    if (Fila.Count > 0) then

      lRequis := Fila.Dequeue

    else

      Sleep(1000);

  end;

end;

A requisição poderia ter sido executada imediatamente após a chamada ao Dequeue, ao invés de dentro do evento OnNotify. Ambas são soluções aceitáveis e, portanto, optar por uma ou outra abordagem é uma questão de gosto.

Uma última consideração: se, por alguma razão, for preciso descobrir quem é o próximo item da fila sem, no entanto, removê-lo, use o método Extract. Uma aplicação disso é mostrar no status informações sobre a requisição que está aguardando para ser executada.

Esse exemplo foi construído com o Delphi XE2; não encontrei informação a respeito da presença da biblioteca Collection em versões anteriores ou em qual versão ela foi introduzida. No próximo post, falo sobre pilhas (ou stacks) e suas aplicações.

Mais Informações
Estruturas de Dados no Wikipedia, Tipos de Estruturas de Dados, Documentação do System.Generics.Collections

Mudanças no envio de e-mails entram em vigor em 1o de Janeiro de 2013

2013-01-02T18:46:00.000-02:00

Com o intuito de reduzir o número de spams e melhorar a segurança no envio de e-mails, o CGI (Comitê Gestor da Internet no Brasil) vem recomendando alterações na forma de se enviar e-mails no país. Em acordo com a Anatel, a Associação Brasileira de Internet e o Sindicato Nacional das Empresas de Telefonia e de Serviço Móvel Celular e Pessoal, algumas alterações já foram implantadas.

Como parte desse acordo, a partir de 1º de Janeiro de 2013 os provedores externos de e-mail deverão desligar o envio de mensagens através da porta 25, substituindo-a pela porta 587. De forma simplificada, uma porta é um canal por onde um computador se comunica com outros computadores (ou com periféricos). São exemplos de provedores externos UOL, BOL, Terra, Zipmail, Speedy, Vivo, GMail e Hotmail. E-mails enviados via modem 3G também estão sujeitos à esta mudança.

A mudança afetará tanto o envio de e-mails através de programas tradicionais de mercado - como o Outlook - quanto aqueles programas que você mesmo tenha construído. É preciso verificar com o provedor do serviço de email utilizado se ele acatará as recomendações, adotando a porta 587 (ou outra) para envio das mensagens; em caso afirmativo, você terá que revisar as configurações dos seus aplicativos para evitar que funcionalidades dependentes do envio de e-mail deixem de operar corretamente.

Empresas que usam servidor de e-mail próprio (como o Exchange) não precisam fazer a conversão, embora isso seja recomendado. Para adotar as recomendações nesse cenário, o TI de sua empresa precisará antes rever as configurações do servidor de e-mail, permitindo que ele envie as mensagens através da porta 587 e exija a autenticação do usuário que deseja fazer o envio.

Reproduzo abaixo matéria a esse respeito publicada no UOL:

Internautas que utilizam configurações antigas em programas de leitura e envio de e-mails, como o Outlook, Windows Mail, Apple Mail ou aqueles instalados no celular, podem não conseguir enviar mensagens a partir de 2013. O Comitê Gestor da Internet no Brasil (CGI) pretende reduzir o volume de spam gerado no país e, por esta razão, solicitou o fim de envios de mensagens sem autenticação, ou seja, sem que o usuário tenha de fornecer login e senha, em todo o território nacional.

A restrição será aplicada para os programas configurados para enviar mensagens (SMTP) pela "porta 25" do computador. Quem usa programas configurados com a "porta 587" ou acessa seus e-mails pelo site do provedor (webmail) não será afetado.

Para que o envio de mensagens não seja interrompido, é preciso alterar configurações do programa de e-mail, modificando a porta de envio 25 para o valor 587, associado ao padrão SMTPS (protocolo seguro para envio de mensagens).

Gerência da Porta 25
O encerramento da porta 25 é uma recomendação do CGI para por fim a um método de envio de mensagens não solicitadas, os ‘spams’, que se aproveita de conexões não autenticadas.

A mudança foi sugerida em acordo com a Anatel, a Associação Brasileira de Internet (Abranet, que reúne provedores e outras prestadoras de serviço na rede) e o Sindicato Nacional das Empresas de Telefonia e de Serviço Móvel Celular e Pessoal (SindiTelebrasil).

Segundo Eduardo Nager, presidente da Abranet, os provedores estão preparados para a mudança há muito tempo, recomendando a utilização de conexões seguras e configurações atualizadas. Para Nager, a grande mudança em 1º de janeiro se dará na parte de acesso físico, a cargo das operadoras de telecomunicações.

Eduardo Levy, diretor executivo do SindiTelebrasil, informou que o prazo para fechamento da porta 25 é o dia 31 de dezembro, acordado entre as suas filiadas, que incluem Oi, Telefônica, GVT e Embratel, além da TIM. As operadoras Oi - responsável por Oi Velox e Oi Velox 3G - e Telefonica - que vende os serviços Vivo Speedy e Vivo 3G - informaram que já seguem as recomendações do CGI.

Apesar de o fechamento ficar a cargo das operadoras, a notifição aos usuários ficou sob responsabilidade dos provedores de e-mails. Os usuários dos e-mails UOL e BOL recebem comunicados regulares sobre as novas configurações desde 2010.

Além de reduzir o volume de spam enviado pelo Brasil (atualmente o sétimo país no ranking de origem de spams, segundo a empresa de segurança Sophos, e quinto, de acordo com levantamento da Kaspersky Labs), a utilização de conexões seguras pelas portas 587 ou 465 desafoga a conexão dos usuários afetados, seus provedores de acesso e dos serviços de e-mail.

Mais do que isso, a medida ajuda a aumentar a confiabilidade dos serviços de e-mails, ajuda nos esforços para criação de filtros cada vez melhores e pode tirar sites brasileiros de listas internacionais para bloqueio de mensagens indesejadas, segundo Nager.

Mais Informações
Envio de e-mails com configuração antiga será encerrado em 2013; saiba corrigir, Repostas às perguntas mais frequentes, Comitê Gestor da Internet no Brasil

Personalizando a apresentação de mapas com o Google Maps

2012-12-19T11:56:00.000-02:00

Na maioria das vezes, as informações apresentadas num mapa produzido através da API do Google Maps são suficientes para que o usuário rapidamente consiga ver um endereço e seu entorno ou a rota a ser seguida para ir de um ponto a outro. Em certas situações, no entanto, pode ser necessário adicionar ao mapa outras informações para melhor transmitir a ideia correta que se deseja.

Esse tipo de necessidade foi exemplificado quando falei sobre o uso de marcações num mapa para apontar locais de interesse nas proximidades de um determinado endereço. O exemplo pode ser encontrado neste link.

A API do Google Maps nos permite acrescentar informações extras aos mapas através do conceito de camadas que são sobrepostas ao mapa, chamadas de overlays. Para isso, a API disponibiliza um conjunto de classes javascript. Além da já citada Marker, há classes para traçar linhas, delimitar áreas circulares ou retangulares e até mesmo para projetar uma imagem personalizada sobre uma área do mapa.

O overlay mais simples é o Polyline, usado para traçar linhas por sobre o mapa. O quadro abaixo traz código javascript que une com uma linha reta 2 pontos do mapa: a sede da ABC71 e a praça da Sé, em São Paulo:

  var mapOptions = {zoom: 10,mapTypeId: google.maps.MapTypeId.ROADMAP};

  map = new google.maps.Map(document.getElementById('map_canvas'), mapOptions);

  geocoder = new google.maps.Geocoder();

  var endDe = new google.maps.LatLng(-23.566146,-46.652579);

  var endAte  = new google.maps.LatLng(-23.550563,-46.633101);

  var request = { location: endDe, region: 'BR'};

  geocoder.geocode (request, function(response, status) {

         if (status == google.maps.GeocoderStatus.OK) {

      map.fitBounds (new google.maps.LatLngBounds(endDe, endAte));

     /* ... */

     var pontos = new google.maps.MVCArray ();

     pontos.push (endDe);

     pontos.push (endAte);

     var rect = new google.maps.Polyline ({

        path: pontos,

        map:map,

        strokeWeight: 5,

        strokeColor: 'blue',

        visible: true

        });

}

    });

Após as inicializações de praxe para o ambiente do Maps, o código solicita a geocodificação do endereço da ABC71 (na verdade, sua latitude/longitude).
Em resposta à conclusão da geocodificação, isto é, assim que o mapa com o endereço solicitado está pronto, eu crio uma lista MVCArray e adiciono a ela os dois pontos que definem a reta desejada.

Em seguida, instancio a classe Polyline propriamente dita, fornecendo-lhe a lista de pontos. Também indico o mapa onde a linha será traçada (map), a espessura da linha em pixels (strokeWeight) e a cor dela (strokeColor). As cores podem ser informadas tanto pelo nome HTML quanto pela notação RGB hexadecimal.

Posso, por exemplo, demarcar um bairro inteiro com esse recurso? Sim, mas você terá que montar a lista de pontos o mais completa possível para que o desenho resultante tenha uma precisão adequada. O Polyline produz linhas abertas; para traçar linhas fechadas com uma quantidade arbitrária de pontos use a classe Polygon.

A função fitBounds, usada no início da resposta, apenas aplica um nível de zoom apropriado para garantir que ambos os endereços sejam exibidos num único quadro, sem que o usuário precise interagir com ele.

O código analisado produz o mapa a seguir:

Imagine agora o caso de uma pizzaria que queira divulgar num mapa o raio de ação onde ela faz entregas. O overlay produzido pela classe Circle permite dar destaque a uma área circular, dado um centro e um raio em metros. Veja o exemplo:

  var endDe = new google.maps.LatLng(-23.566146,-46.652579);

  var request = { location: endDe, region: 'BR'};

  geocoder.geocode (request, function(response, status) {

      if (status == google.maps.GeocoderStatus.OK) {

     map.setCenter(endDe);

     /* ... */

       var circleOpts = ({

            map: map,

            center: endDe,

            editable: false,

            fillColor: 'yellow',

            fillOpacity: 0.4,

            radius: 3500,

            strokeColor: '#0099ff',

            strokeWeight: 4,

            visible: true
          });

       var circle = new google.maps.Circle (circleOpts);

      }

   });

Como no caso da linha, para o círculo também valem as propriedades que indicam o mapa, a cor do traço e sua espessura. Mas, ao invés de uma lista de pontos, informamos apenas o centro; no código anterior, usei o próprio endereço da ABC71 para isso. A definição do círculo fica completa com a propriedade radius - o raio, fornecido em metros; no exemplo, o raio terá 3500 metros (ou 3,5 Km).

Outra configuração disponível diz respeito ao preenchimento da área delimitada pelo círculo. A propriedade fillColor determina a cor do preenchimento enquanto a fillOpacity controla o grau de transparência, sendo que o valor 1 significa totalmente opaco (o mapa sob o círculo não é visto) e o valor 0 suspende o preenchimento.

A propriedade editable, quando ativa, permite ao usuário redimensionar o círculo. Eu a desliguei pois ela não faz sentido no contexto do exemplo. O resultado é o mapa exibido no quadro abaixo:

Os mesmos conceitos valem para a classe Rectangle. Além disso, é permitido trabalhar com vários overlays num mesmo mapa, se for necessário. Os exemplos publicados nesse post podem ser acessados respectivamente nos seguintes links : Overlay com Linha e Overlay com Círculo.

Mais Informações
Usando a versão 3 da API do Google Maps, Overlays no Google Developers

Integrando o Outlook em aplicações Delphi - Parte II

2012-11-23T16:48:00.001-02:00

No último post, eu mostrei os conceitos básicos envolvidos na integração do Outlook com aplicações Delphi. O exemplo apresentado lá abordou a manipulação dos contatos cadastrados no Outlook bem como a criação de novos contatos. Neste post eu abordo o aspecto mais utilizado da ferramenta, que é lidar com envio e recebimento de emails.

Enviar um email com o Outlook de dentro de um programa Delphi é uma operação relativamente simples. Assim como no caso dos contatos, o ponto de partida é objeto Outlook.Application. Aqui, no entanto, não é necessário trabalhar com Namespaces. Basta criar uma instância de MailItem (este é o tipo de objeto do Outlook que representa uma nova mensagem), fornecer-lhe informações relevantes para o envio e, então, efetivamente enviá-la. O código a seguir exemplifica esses passos:

procedure TForm1.btnEnviarClick(Sender: TObject);

var OutlookApp: TOutlookApplication;

    email : MailItem;

begin

  OutlookApp := TOutlookApplication.Create(Nil);

  email := OutlookApp.CreateItem(olMailItem) As MailItem;

  email.Subject := 'Envio automático';

  email.BodyFormat := olFormatHTML;

  email.HTMLBody := 'Este email é um <b>teste</b> para envio <b><span style="color:maroon;">automático</span></b>.';

  email.Importance := olImportanceNormal;

  email.Recipients.Add('balaiotecnologico@gmail.com');

  if (email.Recipients.ResolveAll) then

    email.Send

  else begin

    Application.MessageBox('Um ou mais destinatários não puderam ser resolvidos.'#13+

                           'Reveja a informação e tente novamente.'

                          , 'Alerta', MB_ICONWARNING);

    email.Display(true);

  end;

  OutlookApp.Disconnect;

  OutlookApp.Free;

end;

Veja que a criação da instância da mensagem é feita diretamente no objeto que representa a aplicação Outlook. A função CreateItem usada para esse fim é genérica e permite criar qualquer item dentro do Outlook. Assim, o valor olMailItem passado como parâmetro garante que o que está sendo criado é uma nova mensagem.

Após a criação, eu formato a mensagem fornecendo valores para propriedades relevantes como o assunto (Subject), a prioridade da mensagem (Importance), o texto dela (Body ou HTMLBody, dependendo do formato escolhido) e os destinários que a receberão (Recipients).

Opcionalmente, o método ResolveAll da lista de destinatários é chamado para verificar se os endereços incluídos são válidos. Em caso negativo, a própria tela de envio de email do Outlook é apresentada para que o usuário faça as correções necessárias antes de enviar o email manualmente.

Uma vez que a verificação foi feita com sucesso, a função Send é chamada para efetivar o envio. Por padrão, uma cópia da mensagem é armazenada na pasta Sent Items. Se não quiser guardar a cópia, use a propriedade DeleteAfterSubmit, ajustando-a para true. É possível também indicar outra pasta para guardar a cópia, modificando-se o valor da propriedade SaveSentMessageFolder.

Repare que não informei quem é o remetente da mensagem. Normalmente, o Outlook é configurado para fazer logon automaticamente. O remetente, então, é sempre o usuário que fez o logon, não importando se isso foi feito automaticamente ou de forma explícita no código, via função Logon.

Para finalizar, desconecto do Outlook e a libero a memória usada por ele.

Neste exemplo, passei o valor olFormatHTML na propriedade BodyFormat para permitir a inserção de código HTML diretamente em HTMLBody, o que flexibiliza a formatação da mensagem.

Embora eu não tenha tratado no código, é possível também incluir anexos no email. Um MailItem possui a propriedade Attachments para conter a lista de anexos. Antes do envio, podemos adicionar um ou mais anexos:

email.Attachments.Add('c:\ERP\abc71.jpg', EmptyParam, EmptyParam, EmptyParam);

O primeiro parâmetro é o caminho completo do arquivo a ser anexado. Os demais parâmetros são opcionais; passei EmptyParam a eles para que a função assuma os valores padronizados.

Para encerrar esse tópico, falo de um problema recorrente pra quem automatiza envio de email com o Outlook: a inclusão da assinatura padrão do usuário no corpo da mensagem. Da forma como foi exposto até aqui, apenas o texto incluído em HTMLBody será enviado, sem qualquer decoração extra que o usuário tenha configurado - como a assinatura ou um papel de carta. Isso acontece porque esses recursos não são inerentes ao MailItem mas sim ao editor associado a ele. Para acionar o editor, precisamos apenas invocar o método GetInspector. Um inspector é o responsável pela edição do item atual e, ao invocar o método, todo o ambiente para edição é criado, incluindo a formatação padrão para o item - neste caso, um email.

Isso preencherá o HTMLBody com um HTML completo, englobando a assinatura e outras formatações. Então, teremos que localizar a tag BODY desse HTML para acrescentar nosso texto personalizado no local correto sem perder a formatação padrão. O quadro abaixo mostra como obter esse efeito:

var { ... } 

   email : MailItem;

   insp : Inspector;

   idx: integer;

begin

  { ... }

  insp := email.GetInspector;

  idx := Pos ('<body', email.HTMLBody);

  idx := PosEx ('>', email.HTMLBody, idx);

  email.HTMLBody := MidStr (email.HTMLBody, 1, idx) +

                    'Este email é um <b>teste</b> para envio <b><span style="color:maroon;">automático</span></b>.' +

                    MidStr (email.HTMLBody, idx+1, Length(email.HTMLBody));

  if (email.Recipients.ResolveAll) then

    email.Send;

  {...}

Nessa abordagem, apesar de o editor ser criado e sua configuração padrão ser respeitada, ele não é exibido para usuário. Se for necessário, chame o Display do MailItem para exibí-lo.

Comentei no post anterior mas não custa lembrar: todas as operações descritas neste aqui exigem que o Outlook esteja instalado no computador que for executá-las.

Mais Informações
Integrando o Outlook em aplicações Delphi - Parte I, Outlook Object Model Reference

Integrando o Outlook em aplicações Delphi - Parte I

2012-11-06T18:46:00.002-02:00

Embora eu não tenha números exatos, o Outlook é o programa de email mais utilizado em desktops. Parte desse sucesso se deve à ampla adoção da ferramenta no ambiente corporativo, já que ela também centraliza funções de calendário, acompanhamento de tarefas e agenda de contatos, permitindo compartilhar facilmente as informações.

Um outro aspecto positivo é que o Outlook é componentizado, o que abre caminho para criação de extensões e integrações com outros sistemas. Neste post, mostro como utilizar os recursos COM do Outlook para integrá-lo a uma aplicação Delphi.

Do mesmo modo que as outras aplicações do Microsoft Office (como o Excel), todos os recursos disponíveis do Outlook devem se acessados a partir de um objeto centralizador que representa a própria aplicação. Neste caso, precisamos obter uma instância de Outlook.Application, mapeada pelo Delphi na unit OutlookXP, junto com as demais interfaces existentes para se trabalhar com a ferramenta.

O quadro abaixo mostra um exemplo dos passos básicos necessários para interagir com o Outlook. O código apresentado percorre os contatos registrados na pasta local do Outlook, listando informações de cada um deles numa tabela:

procedure TForm1.btnListarContatosClick(Sender: TObject);

var i : integer;

    OutlookApp: TOutlookApplication;

    ns : NameSpace;

    pasta: MAPIFolder;

    contato : _ContactItem;

begin

  StringGrid1.RowCount := 2;

  OutlookApp := TOutlookApplication.Create(Nil);

  ns := OutlookApp.GetNamespace('MAPI');

  pasta := ns.GetDefaultFolder(olFolderContacts);

  for i := 1 to pasta.Items.Count do

  begin

    if (i > 1) then

      StringGrid1.RowCount := StringGrid1.RowCount + 1;

    contato := pasta.Items.Item(i) As _ContactItem;

    StringGrid1.Cells [1,i] := contato.FullName;

    StringGrid1.Cells [2,i] := contato.Email1Address;

    StringGrid1.Cells [3,i] := contato.EntryID;

    StringGrid1.Cells [4,i] := contato.CompanyName;

    StringGrid1.Cells [5,i] := contato.BusinessAddress;

  end;

  OutlookApp.Disconnect;

  OutlookApp.Free;

end;

Vamos destrinchar esse código. Após criar uma instância para acessar a aplicação (classe TOutlookApplication), o trecho recupera um tipo de objeto denominado Namespace. Atualmente, apenas o namespace MAPI (API de Mensagens do Windows) está disponível, concentrando todos os registros, isto é, os emails, contatos, tarefas e entradas do calendário. Um Namespace é organizado em pastas dispostas hierarquicamente, podendo haver pastas dentro de pastas para armazenar os itens.

Há algumas formas de acessar as pastas do Outlook. A propriedade Folders do Namespace lista todas as pastas, incluindo as compartilhadas com outros usuários no servidor. As subpastas eventualmente existentes são acessíveis por meio de propriedade Folders própria. E como saber que tipo de item uma pasta contém? Em princípio, pode-se consultar a propriedade DefaultItemType para se ter uma ideia. Mas, certas pastas (como a DeletedItems) podem conter itens de tipos diferentes misturados. Neste caso, recomenda-se checar a propriedade Class do item ou fazer um cast dinâmico para o tipo desejado e ver se a conversão foi bem sucedida.

Outra forma de acesso é requerer ao Namespace a pasta padrão para um determinado tipo de item, como no código mostrado acima. Lá, uso GetDefaultFolder para recuperar exclusivamente a pasta que armazena meus contatos. Por fim, se eu possuir a identificação única da pasta (seu entryID, posso recuperá-la diretamente com a função GetItemFromID do Namespace.

Voltando ao código, agora tenho uma instância da pasta de contatos para trabalhar. Como toda pasta, esta possui uma lista Items que dá acesso ao conteúdo específico - no exemplo, os contatos cadastrados. Então, percorro a lista para prencher a tabela com as informações desejadas de cada um dos contatos.

Para concluir, desconecto minha instância do Outlook e removo-a da memória para liberar os recursos utilizados.

Note que não foi preciso informar usuário e senha para fazer logon. Isso acontece porque o Outlook pode ser configurado para se conectar automaticamente com o mesmo usuário do Windows. Se for preciso, pode-se logar manualmente usando a função Logon do Namespace.

Aproveitando os mesmos conceitos, podemos criar automaticamente um novo contato, conforme mostra o trecho de código a seguir:

contato := pasta.Items.Add(olContactItem) As _ContactItem;

contato.FirstName := 'Balaio';

contato.LastName := 'Tecnológico';

contato.CompanyName := 'ABC71 Soluções Em Informática';

contato.Save;

contato.Display(1);

Como se vê, a criação é bastante simples. Primeiro, chamo o método Add da lista de itens da pasta, fornecendo-lhe o tipo de item que deve ser criado - um item de contato, neste caso. Após prover algumas informações básicas do contato, salvo o registro. A última linha não é imprescindível; ela apenas exibe no próprio Outlook o contato recém-criado para que o usuário possa complementar as informações, se desejar.

De forma similar, conseguimos trabalhar com tarefas e compromissos no calendário. Também é possível fazer o envio de email aproveitando a infraestrutra já configurada do Outlook, operação que mostro no próximo post.

Obviamente, todos os recursos apresentados aqui exigem que haja uma cópia do Outlook instalado no computador local para funcionar.

Mais Informações
Outlook Object Model Reference, Working with Microsoft Outlook Objects

Trabalhando com marcações em mapas com a versão 3 da API do Google Maps

2012-10-02T14:49:00.002-03:00

Além dos tradicionais recursos de exibir o mapa para um determinado endereço ou traçar rotas entre endereços fornecidos, a API do Google Maps disponibliza um outro recurso bastante interessante que permite incluir num mapa marcações customizadas. Com isso, você pode marcar pontos de interesse de acordo com as necessidades de sua aplicação. Um exemplo de aplicabilidade desse conceito seria indicar num mapa a localização de estabelecimentos comerciais nas proximidades de um endereço, tais como Caixas 24 Horas, Supermercados, escolas de inglês ou outro qualquer. Obviamente, isso demandará saber de antemão a posição de cada um dos locais passíveis de serem marcados no mapa.

O processo de marcação em si é bastante simples. Após termos ajustado a parametrização inicial do ambiente do Maps e requisitado a exibição de um endereço (veja post Usando a versão 3 da API do Google Maps), basta criar uma instância da classe google.maps.Marker, como no quadro abaixo:

function mostraEnderecoABC71 () {

   var lRequest = { address: 'Alameda Santos, 1000, São Paulo - SP, 01418-902', region: 'BR'};

   geocoder.geocode( lRequest, trataLocais);

}

function trataLocais (results, status){

  if (status == google.maps.GeocoderStatus.OK)

  {

    map.setCenter(results[0].geometry.location);

    var marker = new google.maps.Marker(

                  {map: map, 

                   position: results[0].geometry.location, 

                   animation: google.maps.Animation.DROP, 

                   icon: 'http://maps.google.com/mapfiles/kml/pal3/icon18.png',

                   shadow: 'http://maps.google.com/mapfiles/kml/pal3/icon18s.png'

                  });

      /* ... */

  }

}

A função trataLocais reproduzida acima é o callback passado para o Geocoder junto com a requisição do endereço a ser apresentado no mapa. No exemplo, a marcação é inserida no próprio endereço requisitado, razão pela qual foi usado o retorno da API results[0].geometry.location como local para fixar a marcação.

Dos parâmetros para criar o marcador, apenas 2 são obrigatórios : o map (representando a instância de Map que gerencia a apresentação do mapa na página) e o position (um par latitude/longitude onde o marcador deverá ser fixado). Os demais parâmetros são auxiliares, úteis para melhorar a apresentação. No exemplo, forneço outros 3 parâmetros : animation (uma animação dinâmica usada para cravar o marcador no mapa; o padrão é o marcador simplesmente aparecer), icon (uma URL apontando a imagem que será usada como marcador; o padrão é ) e shadow (URL com a imagem que representa uma sombra do marcador). Há uma lista com imagens padronizadas e suas respectivas sombras neste link mas pode-se trabalhar com qualquer URL personalisada que se queira.

O mapa abaixo usa esses conceitos pra incluir algumas marcações nas proximidades da sede da ABC71 em São Paulo:

A API prevê ainda a possibilidade de se abrir uma janela para apresentar outros detalhes a respeito de um ponto no mapa. A flexibilidade desse tipo de recurso é grande já que é permitido incluir código HTML para formatar as informações que são apresentadas - embora isso não seja obrigatório.

Do ponto de vista da programação, criar uma janela com informações adicionais sobre um ponto também é simples. Consiste em instanciar a classe google.maps.InfoWindow, providenciando um conteúdo para essa janela. Uma vez instanciada, podemos solicitar que a janela seja aberta num ponto específico do mapa. Complementando a função trataLocais :

function trataLocais (results, status){

  if (status == google.maps.GeocoderStatus.OK)

  {

      /* ... */

    google.maps.event.addListener(marker, 'click',

      function () {

        var infowindow = new google.maps.InfoWindow(

          {

            content: '<div style="text-align:justify;"><b>Ponto de Interesse</b><br/><br/>ABC71 Soluções em Informática.</div>'

          });

        infowindow.open(map, marker);

     });

  }

}

No código javascript do quadro anterior, a abertura da janela de informação é vinculada a um evento de "clique" no marcador. Isto é, ela só aparece se o usuário clicar no marcador em questão. Veja que o conteúdo (content) da janela foi formatado com tags HTML, possibilitando adequar a apresentação ao propósito de sua aplicação. A função open - que exibe a janela - aceita como parâmetros o mapa que estamos usando e o marcador que servirá de referência para a exibição da janela.

No mapa que aparece nesse post, os marcadores podem ser clicados, ação que cria uma janela simples com outras informações sobre o ponto marcado.

O arquivo HTML encontrado neste endereço traz o exemplo completo mostrado aqui no post. Ele simula a recepção em formato XML de informações sobre locais que devem ser marcados no mapa. Para isso, o exemplo utiliza também recursos da biblioteca JQuery.

Mais Informações
Usando a versão 3 da API do Google Maps, Informações sobre rotas com a versão 3 da API do Google Maps

ABC71 busca parceiros de tecnologia para comercializar ERP na nuvem

2012-09-27T17:42:00.001-03:00

A ABC71, empresa de desenvolvimento de softwares de gestão empresarial, acaba de lançar uma versão em cloud computing de seu ERP Omega. A solução - batizada de ERP Pronto - funciona na internet, dispensando seus clientes de preocupações com infraestrutura de hardware e software para a instalação. Basicamente, é preciso apenas ter um navegador compatível e a disponibilidade de uma conexão com a internet. Ficam a cargo da fornecedora do software os demais aspectos, tais como a preparação de um servidor, configurações gerais, controles de segurança, instalação e gerenciamento do banco de dados (incluindo backup sistemático dos dados lançados pelos usuários), etc.

A empresa preparou o site ERP Pronto para apresentar os principais benefícios do novo produto. Nele é possível encontrar detalhes sobre as diversas operações que o software é capaz de gerenciar, cobrindo faturamento, finanças, estoques, NF-e Federal, SPED, entre outros. O site também aborda dúvidas comumente levantadas, além de apresentar vídeos demonstrando algumas das operações do sistema.

Agora, a ABC71 está buscando firmar parcerias com novos canais de venda para levar a solução aos potenciais clientes, mesmo aqueles que se encontram longe dos chamados "grandes centros". O texto abaixo foi preparado com o objetivo de auxiliar nessa busca, dando outras características do produto, o modo de aquisição e os preços praticados para um cenário típico de pequenas empresas, que é o foco do produto.

ABC71 busca parceiros de tecnologia para comercializar o ERP Pronto

Consultorias especializadas em TI podem representar a solução e aumentar a rentabilidade

A ABC71 – empresa nacional especializada no desenvolvimento de softwares de gestão empresarial – está investindo em sua rede de canais para ampliar as vendas do ERP Pronto.

O ERP PRONTO é um sistema de gestão completo baseado em Cloud Computing e voltado para pequenas e médias empresas. O software pode ser utilizado pelos mais variados segmentos da economia e está preparado para atender às principais necessidades de gestão dos negócios das PMEs (pequenas e médias empresas), atende às áreas comercial, financeira, estoque, contábil e fiscal, incluindo o SPED (Sistema Público de Escrituração Digital) e a NF-e (Nota Fiscal Eletrônica).

O ERP Pronto é comercializado na modalidade SaaS (software como serviço), dispensando a contratação de licença de uso e investimentos em infraestrutura de TI. Funciona como uma conta telefônica onde só se paga pelo o que se usa. O pacote inicial do ERP Pronto está disponível a partir de R$ 510,00 por mês para que até três usuários possam utilizá-la simultaneamente.

Para chegar às PMEs, pulverizadas pelo país, e atingir a meta de vendas em torno de três mil clientes até 2015, a ABC71 procura empresas especializadas em TI que queiram aumentar a rentabilidade.

Entre os canais já credenciados estão: TCi Sistemas, RM Benasse, KLX, Freestore, Publisoft, Lesoft e Viera e Souza Assessoria Contábil.

Entre clientes que já utilizam a solução destacam-se: a Fazenda Novo Horizonte, produtora de grãos do Mato Grosso; a Foccus, distribuidora de ferramentas de corte; e a Invento, importadora de artigos de decoração.

Para se tornar parceiro da ABC71 basta entrar em contato pelo telefone (11) 2179-3190 ou pelo e-mail erppronto@erppronto.com.br.

Mais Informações
Site do ERP Pronto

Avaliando a performance de queries no SQL Server

2012-08-28T19:03:00.000-03:00

Muito da aceitação de um programa de computador por seus usuários pode ser atribuído à praticidade de sua interface gráfica e até mesmo a aparência que ela tenha. No entanto, a aceitação rapidamente se reverte se o programa apresentar problemas de performance. Com bastante frequência, a degradação de performance num programa está associado a queries mal projetadas submetidas a um banco de dados pelo programa.

Quando digo "mal projetada", eu me refiro a certas características das queries adotadas pelo programa, tais como não utilizar os índices apropriados das tabelas ou manter tabelas sem índice, fazer ligações ineficientes com outras tabelas, trazer registros demais que não serão utilizados ou ainda executar uma mesma query mais vezes do que o necessário.

A partir da sua versão 2005, o SQL Server mantém em tabelas virtuais uma série de informações a respeito das queries que foram executadas pelo banco de dados. Essas informações ficam armazenadas em memória e são descartadas quando o serviço do banco é desligado. No entanto, são informações bastante úteis para auxiliar na localização de problemas de performance gerados pelas queries mal planejadas.

Um usuário que queira consultar as informações disponibilizadas nessas tabelas virutais precisa ter atribuida a permissão VIEW SERVER STATE. Isso pode ser feito visualmente, através das propriedades do servidor no Management Studio ou via comando SQL, utilizando-se o GRANT.

Uma das views mais interessantes nesse contexto é a sys.dm_exec_query_stats, responsável pelas estatísticas de execução de queries. Ela traz, dentre outras informações, a quantidade de vezes que uma query foi executada, o tempo gasto nessas execuções, quantas linhas foram retornadas, a quantidade de leituras e gravações feitas durante a execução. Ela dá acesso também ao texto da query e ao plano de execução montado pelo SQL. O exemplo no quadro abaixo lista em ordem decrescente as queries que mais consumiram CPU:

SELECT qs.total_worker_time / qs.execution_count As 'Uso Médio da CPU',

       qs.total_worker_time As 'Uso Total da CPU',

       qs.execution_count As 'Qtde de Execuções',

       qt.text As 'Query',

       DB_NAME(qt.dbid) As 'Nome do Banco'

FROM sys.dm_exec_query_stats qs

CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) As qt

ORDER BY 1 DESC

Veja que a quantidade de vezes que uma query executou não é determinante para que ela tenha consumido mais CPU na média. Consulta semelhante pode ser montada para obter as queries que mais foram executadas (pra avaliar se todas as execuções são mesmo necessárias) ou a quantidade de linhas retornada (pra avaliar se não é possível restringir mais os registros, acrescentando outras comparações à cláusula WHERE). Os tempos listados estão em microsegundos; para convertê-lo em segundos, divida o valor por 1 milhão. É possível ainda levantar a quantidade de gravações feitas por uma query e avaliar se tantas alterações são mesmo necessárias

Outro detalhe a ser destacado no quadro anterior é que o texto da query não está na mesma view. Para obtê-lo, é necessário pegar o código contido no campo sql_handle e repassá-lo à função sys.dm_exec_sql_text.

Outra view bastante útil é a sys.dm_db_missing_index_details. Como o próprio nome diz, ela armazena detalhes sobre o uso de queries cujas execuções não estão otimizadas por que não foi possível encontrar na tabela um índice apropriado. Baseado nas informações retornadas por ela, podemos introduzir novos índices e melhorar a performance das consultas envolvendo as tabelas em questão. O quadro abaixo mostra um exemplo de consulta a essa view, listando as colunas encontradas na cláusula WHERE da query com problema, a tabela envolvida e a quantidade de vezes que a query problemática foi disparada:

SELECT equality_columns, inequality_columns, statement, count(*) As 'Qtde Exec'

FROM sys.dm_db_missing_index_details

WHERE DB_NAME(database_id) = 'ABC71DS94'

GROUP BY equality_columns, inequality_columns, statement

ORDER BY statement

A coluna statement traz o nome da tabela que está sem índice apropriado. A equality_columns lista as colunas usadas em comparações de igualdade no WHERE - algo como NOME_DO_CAMPO = VALOR. Em inequality_columns aparecem as colunas usadas em outros tipos de comparação do WHERE. Veja que é possível filtrar as informações por banco de dados instalado, permitindo avaliar os índices para cada banco isoladamente.

A lista de informações que podemos obter no DMV (Dynamic Management Views) inclui ainda os motivos de espera para uma query ser executada, dados de espelhamento e replicação, tamanho do banco de dados e suas partições, etc. A lista completa das informações disponíveis por esse meio pode ser encontrada em Dynamic Management Views and Functions no MSDN online.

Mais Informações
Uncover Hidden Data to Optimize Application Performance, Dynamic Management Views and Functions (Transact-SQL)

Aplicações em Java ainda valem a pena ?

2012-08-01T18:48:00.002-03:00

Depois de protagonizar o primeiro grande ataque a sistemas Mac OS no início deste ano, quando uma vulnerabilidade crítica permitiu a infecção de mais de 600 mil Macs, o Java volta a ficar na berlinda. Desta vez, um pesquisador do Centro de Proteção a Malwares da Microsoft publicou um artigo intitulado "Como se proteger de malwares baseados em Java" onde aconselha os usuários a trabalharem sempre com as releases mais recentes da Virtual Machine e, quando for possível, que a deixem desativada para proteger seus sistemas. No caso de não utilizar aplicações Java, a recomendação é de remover completamente o JRE.

Na mesma linha, só que um pouco mais radical, Woody Leonhard defendeu em artigo publicado na InfoWorld.com que a melhor opção é mesmo abandonar a tecnologia, substituindo-a o mais rápido possível. O texto abaixo é uma tradução do artigo onde ele expressa sua opinião:

Quatro meses atrás, eu critiquei o Java -- ou, mais apropriadamente, o uso do Java Runtime Environment (JRE) -- no post "É hora de expulsar o Java da cidade". Quatro meses depois, a situação não melhorou um milímetro. De fato, ela piorou, se é que piorar é uma opção para o vetor de infecção número 1 em PCs e Macs.

Na semana passada, o pesquisador Matt Oh do Centro de Proteção Contra Malware da Microsoft publicou um artigo no TechNet sobre como se proteger contra os malwares baseados em Java. Para enfatizar o ponto, ele deu uma palestra no Black Hat 2012 no mesmo dia, dizendo que a situação com o Java está se deteriorando -- e não somente no Windows.

"Estamos vendo cada vez mais vulnerabilidades no Java sendo exploradas ... e uma vulnerabilidade no Java pode às vezes ser explorada em múltiplas plataformas," disse o pesquisador.

A principal preocupação para Oh são as brechas no sandbox. Se autores de malware conseguirem acesso fora dos limites do sandbox de execução do Java/JRE, eles podem tomar o controle de um sistema, não importando se ele está em Windows, Mac OS X ou Unix. Uma única vulnerabilidade no Java -- como a brecha de segurança "confusão de tipos" CVE-2012-1723, descoberta há apenas algumas semanas, ou a velha CVE-2012-0507, que levou à rede de robôs Flashback, com mais de 600 mil Macs infectados neste ano -- pode resultar numa exploração bem sucedida que burle as defesas do sistema operacional simplesmente por ele estar executando o Java.

"A confusão de tipos é uma vulnerabilidade que ocorre quando a verificação de segurança de tipos feita pelo JRE falha quando são fornecidos tipos diferentes do esperado para uma instrução. Alguns dos tipos do Java, como o ClassLoader, podem ser alvos desse ataque. Se a segurança de tipos dessas classes é quebrada, pode-se ter acesso a alguns métodos que não deveriam estar acessíveis a processos externos à própria classe. Esta violação na segurança de tipos leva, em última análise, ao comprometimento do sandbox do Java," disse Oh.

Para piorar, o fato do programa ser escrito em Java torna mais fácil ocultar a violação usando ferramentas disponíveis e bem documentadas da própria linguagem para embaralhar o código.

A recomendação de Oh é que você esteja sempre com o JRE mais atualizado e que o desabilite sempre que isso for possível. Se você não usa aplicações Java, então simplesmente desinstale o JRE.

Minha recomendação para TI é um pouco mais proativa: é hora de tirar seus usuários da esteira do JRE/JVM. Se você tem um produto que requer o JRE, migre-o. Se seus planos de negócio incluem aplicações Java, altere seus planos. Se você ou sua equipe de desenvolvimento programam aplicações client Java, é hora de diversificar suas habilidades.

Ao continuar usando Java, você está colocando sua empresa e seus clientes em risco.

Embora eu entenda as razões dele e concorde com sua argumentação - que é irretocável, considerando-se a agudez da crise atual - acredito que ainda seja cedo pra tomar uma decisão tal radical quanto simplesmente abdicar das aplicações feitas em Java. Digo isso porque me parece que a Oracle vem mantendo um plano razoavelmente consistente de atualizações da linguagem. Veja, por exemplo, o projeto JigSaw e os planos para levar Java para o iOS.

Apesar de às vezes a Oracle pecar na velocidade das correções, creio que o ideal é seguir as recomendações de Matt Oh: manter sempre atualizado o JRE e eventualmente desligá-lo (se possível) quando brechas críticas forem detectadas e a correção demorar a sair.

Mais Informações
Microsoft hits Java where it hurts, How to protect yourself from Java-based malware

Assinando documentos XML com CAPICOM e Delphi

2012-07-18T17:35:00.000-03:00

A Microsoft disponibiliza para o Windows uma biblioteca com tecnologia COM para tratar a criação e manipulação de arquivos XML. A biblioteca, chamada MSXML, está atualmente na versão 6 e suporta também transformações XSLT e validação através de esquemas XSD. Em apenas uma das versões (o MSXML5), foram incluídos ainda recursos para fazer assinatura digital de XMLs.

A versão 5 foi distribuída exclusivamente com o Microsoft Office para que os desenvolvedores dessa plataforma pudessem assinar XMLs. No entanto, uma busca na internet revela que a biblioteca é amplamente utilizada fora desse contexto.

Isto é uma boa notícia para quem usa Delphi (ou outra linguagem que suporte COM) pois o MSXML5, em associação com o CAPICOM, facilita bastante a tarefa de assinar XMLs. Neste post eu mostro como realizar este processo, considerando que você já tem montado o XML que quer assinar. O quadro abaixo mostra parte do XML de uma Nota Fiscal que vou usar como exemplo:

<?xml version="1.0" encoding="UTF-8" ?>

<enviNFe versao="2.00" xmlns="http://www.portalfiscal.inf.br/nfe">

<idLote>71</idLote>

<NFe>

<infNFe Id="NFe3508059978" versao="2.00">

 <cUF>35</cUF>

 <cNF>518005127</cNF>

 <natOp>Venda a vista</natOp>

 <mod>55</mod>

 <serie>1</serie>

 <dEmi>2012-05-06</dEmi>

 <tpAmb>2</tpAmb>

</infNFe>

</NFe>

  </enviNFe>

A primeira providência é importar os fontes dos ActiveX MSXML5 e CAPICOM para podermos utilizá-los no projeto Delphi. Há um resumo de como fazer essa importação neste endereço; para o MSXML5, a descrição da Type Library é Microsoft XML, v5.0. Ambos os fontes gerados devem ser incluídos na cláusula uses da unit que for fazer a assinatura.

Obviamente, vamos precisar de um certificado digital para realizar a assinatura. Utilizando o CAPICOM, podemos acessar o Certificate Store do Windows e localizar um apropriado, que tenha sido gerado para sua empresa. No entanto, as interfaces disponíveis no MSXML5 exigem que você informe um Certificate Store com o certificado que será utilizado, bem como sua cadeia de validação, se for necessário. Este passo extra é mostrado no quadro abaixo.

var store : IStore3;

    cert : TCertificate;

    lKey : IPrivateKey;

begin

  cert := getCert;

  lKey := Cert.PrivateKey;

  { Monta um Store em memória com o Certificado obtido antes }

  store := CoStore.Create;

  store.Open(CAPICOM_CURRENT_USER_STORE, 'My', CAPICOM_STORE_OPEN_MAXIMUM_ALLOWED);

  store.Add(cert.DefaultInterface);

  { ... }

A função GetCert utilizada acima é minha e segue as instruções descritas no post sobre acesso ao Certificate Store com CAPICOM. De resto, o código apenas cria um Store em memória e adiciona a ele o certificado encontrado. O trecho também salva a chave privada deste certificado, informação que será usada mais adiante para gerar a assinatura em si.

A seguir, precisamos preparar o XML do exemplo para receber a assinatura. É que a interface do MSXML5 responsável por essa etapa se baseia num nó Signature do XML. Esse nó descreve as transformações pelas quais o XML deve ser submetido antes de ser de fato assinado. O nó Signature deve ser criado como mostrado abaixo:

<?xml version="1.0" encoding="UTF-8" ?>

<enviNFe versao="2.00" xmlns="http://www.portalfiscal.inf.br/nfe">

<idLote>71</idLote>

<NFe>

{ ... }

<Signature>

<SignedInfo>
<CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>

<Reference URI="#NFe3508059978"

<Transforms>

<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>

<Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

</Transforms>

<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>

<DigestValue></DigestValue>

</Reference>

</SignedInfo>

<SignatureValue><SignatureValue>

</Signature>

</NFe>

  </enviNFe>

Como podemos ver acima, o nó também deixa reservado um local para receber o hash (DigestValue) e outro para a própria assinatura (SignatureValue), que serão preenchidos automaticamente. A única parte variável do bloco preparado acima é o atributo URI da tag Reference, valor que reflete a identificação da Nota Fiscal contida no XML. Ou seja, deve-se montar o valor desse atributo a partir do valor do atributo Id da tag infNFe, precedendo este valor com o sinal #. Como o próprio nome diz, essa parte do XML faz referência ao nó (e seus filhos) que será resguardado pela assinatura digital.

Uma vez que o XML está preparado, podemos partir para a assinatura propriamente dita, o que é conseguido através da interface IXMLDigitalSignature do MSXML5. Então, precisamos criar uma instância dela e lhe fornecedor os dados para a assinatura:

var {...}

    xmlDoc: IXmlDomDocument3;

    noSignature : IXMLDOMElement;

    xmlSign : IXMLDigitalSignature;

    xmlDsigKey: IXMLDSigKey;

begin

  {...}

  { Monta o XML e prepara a tag Signature }

  xmlDoc := PreparaXML ();

  noSignature := EncontraNodeSignature (xmlDoc);

  if (noSignature <> Nil) then begin

      xmlSign := CoMXDigitalSignature50.Create;

      xmlSign.signature := noSignature;

      xmlSign.store := store;

      { Monta a chave com o tipo exigido pelo método Sign }

      xmlDsigKey := xmlSign.createKeyFromCSP(lKey.ProviderType, lKey.ProviderName, lKey.ContainerName, 0);

      { Assina o XML }

      xmlSign.sign(xmlDsigKey, NOKEYINFO);

     {...}

  end;

end;

Como podemos ver no trecho de código acima, o IXMLDigitalSignature precisa que indiquemos qual é o nó Signature do nosso XmlDomDocument e o Certificate Store que construímos no início do post. Agora, temos que chamar o método sign para completar o serviço. Para funcionar, ele precisa de algumas informações baseadas na chave privada do certificado. No exemplo acima, utilizei a chave recuperada a partir do certificado para criar uma instância da interface IXMLDSigKey contendo as informações necessárias.

O segundo parâmetro da função sign determina como os dados da chave serão incluídos na estrutura do XML. No exemplo, usei o valor NOKEYINFO para que tais dados não sejam incluídos automaticamente.

Após chamar a função sign, as tags que deixamos reservadas no nó Signature são automaticamente calculadas e preenchidas. Finalizando, para que o XML fique no padrão exigido para Notas Fiscais pela Receita Federal, só falta incluir um nó com os dados do certificado usado para assinar. Mostrei como fazer isso no post Certificado Digital para inclusão no XML com CAPICOM e Delphi.

Mais Informações
XML Digital Signatures Reference, Preparando o Certificado Digital para inclusão no XML com CAPICOM e Delphi

Trabalhando com informações sobres tipos no Delphi em tempo de execução - parte II

2012-06-22T19:23:00.001-03:00

A extensão do mecanismo de RTTI (Run Time Type Information) introduzida no Delphi 2010 - e que eu citei no meu último post - abre novas possibilidades de soluções para arquitetura de softwares feitos em Delphi. Isso é particularmente útil para desenvolvedores de infraestrutura de software, situação onde é comum a necessidade de se criar rotinas genéricas para certas tarefas.

Customizar classes estendendo o RTTI também permite melhorar a organização da solução já que estas classes serão mais coesas. Isto é, funcionalidades que não são centrais podem ser transferidas para outras classes associadas. É o caso, por exemplo, da exportação de objetos para XML (ou outro formato qualquer), processo conhecido como serialização.

Estender o RTTI significa fazer marcações em classes, métodos, campos ou propriedades, introduzindo características extras no elemento marcado. Como a marcação também é uma classe, podemos criar comportamentos auxiliares complexos.

O quadro abaixo mostra a declaração de uma classe simples que possui algumas marcações para permitir exportar seu conteúdo como um XML:

[TWXmlExportable('notaFiscal')]

  TWNota=class

  public

    [TWXmlExportableNode('nro')]

    Numero : longint;

    [TWXmlExportableNode('serie')]

    Serie : String;

    [TWXmlExportableNode('observ')]

    Observ: String;

    [TWXmlExportableNode('vlrTotal')]

    Valor: Double;

    InfoNaoExport : String;

    procedure GravaNota;

  end;

Como podemos ver, a marcação de um elemento é feita colocando-se um par abre e fecha colchetes antes da declaração desse elemento, inserindo entre eles o nome da classe usada para marcá-lo. No exemplo, há duas classes de marcação sendo usadas - TWXmlExportable e TWXmlExportableNode, sendo que ambas aceitam um parâmetro do tipo string em seus construtores, o que também é fornecido na marcação do exemplo. Aqui, o parâmetro indica o nome da tag XML que conterá o elemento marcado. Observe que nem todos os campos foram marcados; apenas aqueles que eu quero exportar.

As classes de marcação são também chamadas de atributos e em Delphi têm obrigatoriamente que ser heranças da classe TCustomAttribute. A declaração das classes usadas no exemplo está na listagem a seguir:

TWXmlExportable = class(TCustomAttribute)

  protected

    FIsRoot: Boolean;

    FTagName: String;

  public

    constructor Create (ATagName: String); virtual;

    property TagName : String read FTagName;

    property IsRoot: Boolean read FIsRoot;

  end;

  TWXmlExportableNode = class(TWXmlExportable)

  public

    constructor Create (ATagName: String); override;

  end;

 { ... }

constructor TWXmlExportable.Create (ATagName: String);

begin

  inherited Create;

  FTagNAme := ATagName;

  FIsRoot := true;

end;

constructor TWXmlExportableNode.Create (ATagName: String);

begin

  inherited Create(ATagName);

  FIsRoot := false;

end;

Introduzi nelas a propriedade IsRoot para poder diferenciar classes - que são elementos compostos por outros elementos - dos demais tipos. Assim, os campos de uma classe poderão ser aninhados em uma tag, enquanto cada campo de tipo básico é exportado em sua tag individual. Com isso, a exportação funcionará corretamente até mesmo com classes que possuam outros objetos exportáveis em sua estrutura.

Portanto, essas classes de marcação podem ser aplicadas livremente a quaisquer outros elementos no programa. A grande vantagem é que tal flexibilidade nos permite montar uma rotina genérica que seja capaz de exportar para XML qualquer objeto que contenha as marcações apropriadas. Da mesma forma que recuperamos a lista de métodos de um objeto no outro post, podemos interagir com os atributos desse objeto:

function TForm1.GetExportToXml (AObj: TObject) : TWXmlExportable;

var i : integer;
    lTipo: TRttiType;

begin

  Result := Nil;

  {_RttiCntxt é um TRttiContext instanciado em outro ponto do sistema }

  lTipo := _RttiCntxt.GetType(AObj.ClassType);

  { Obtem os atributos - ou marcações - do objeto }

  i := Length (lTipo.GetAttributes()) - 1;

  { Verifica se algum dos atributos é do tipo TWXmlExportable; isso significa que o objeto passado no parâmetro é "exportável" }

  while (Result = Nil) And (i >= 0) do begin

    if (lTipo.GetAttributes()[i] is TWXmlExportable) then

      Result := (lTipo.GetAttributes()[i] As TWXmlExportable);

    Dec (i);

  end;

end;

A exportação para XML, então, passa a ser uma questão de levantar quais são os campos do objeto, determinar quais desses campos são "exportáveis" usando a mesma técnica acima, obter o nome da tag e o valor do campo. A função listada no quadro abaixo faz a exportação, seguindo esses passos:

function TForm1.ExportToXml (AObj: TObject) : string;

var lTipo: TRttiType;

    lCampo: TRttiField;

    lAttrib : TCustomAttribute;

    lExpField, lExpObj : TWXmlExportable;

begin

  Result := '';

  lExpObj := GetExportToXml (AObj);

  { só continua se o objeto é "exportável" }

  if lExpObj <> Nil then begin

    lTipo := _RttiCntxt.GetType(AObj.ClassType);

    { Inicia a tag XML, obtendo o nome no atributo encontrado para o objeto }

    Result := '<' + lExpObj.TagName + '>';

    { Quais são os campos nesse tipo de classe ? }

    for lCampo in lTipo.GetFields() do begin

      { Analisa os atributos do campo pra ver quais são exportáveis }

      for lAttrib in lCampo.GetAttributes() do

        if (lAttrib is TWXmlExportable) then begin

          lExpField := lAttrib As TWXmlExportable;

          if (lExpField.IsRoot) then

            { campos do tipo classe são exportados recursivamente }

            Result := Result + ExportToXml (lCampo.GetValue(AObj).AsObject)

          else begin

            { campos de tipos simples apenas envolve com o nome da tag contido no atributo do campo }

            Result := Result + '<' + lExpField.TagName + '>';

            { Obtem o valor atual do campo }

            Result := Result + lCampo.GetValue(AObj).toString();

            Result := Result + '</' + lExpField.TagName + '>';

          end;

        end;

    end;

    { Encerra a tag desse objeto }

    Result := Result + '</' + lExpObj.TagName + '>';

  end;

end;

As informações sobre cada campo de uma classe são mantidas em instâncias de TRttiField. Além dos eventuais atributos associados ao campo, podemos descobrir com ela o nome do campo, seu tipo e sua visibilidade (público, protegido ou privado). Ela também fornece meios para recuperarmos ou modificarmos o valor do campo, conforme podemos ver no quadro anterior.

Agora, para exportar uma instância da classe de Nota precisamos apenas passá-la para a função acima. Na verdade, a função é genérica o suficiente pra ser capaz de exportar para XML instâncias de qualquer classe anotada com os atributos apresentados aqui.

Do jeito que esse recurso funciona, a classe de Nota apresentada no início do post pode focar na implementação das tarefas inerentes ao negócio, deixando a tarefa acessória de exportar os dados para outros pontos do sistema, favorecendo a coesão das classes na solução.

Mais Informações
Trabalhando com informações sobres tipos no Delphi em tempo de execução - parte I, RTTI - Practical Examples, Classe TCustomAttribute

Trabalhando com informações sobres tipos no Delphi em tempo de execução - parte I

2012-06-01T15:20:00.002-03:00

Em muitas situações num programa é conveniente saber o tipo de dado exato com o qual uma rotina está trabalhando, principalmente quando envolve objetos complexos. Dependendo do cenário, é preciso tomar uma decisão baseada no tipo e acessar propriedades e métodos do tipo específico.

Imagine, por exemplo, que você queira garantir que os textos nas telas do seu sistema sejam exibidos usando uma fonte predeterminada. Ao invés de ajustar o fonte manualmente em cada componente da tela, podemos percorrer a lista de componentes e automatizar o ajuste:

procedure TForm1.FormCreate(Sender: TObject);

var i : integer;

    lLabel : TLabel;

begin

  for i := 0 to ComponentCount - 1 do

    if (Components[i] is TLabel) then begin

      lLabel := Components[i] as TLabel;

      lLabel.Font.Name := 'Calibri';

      lLabel.Font.Color := clBlue;

      lLabel.Font.Size := 10;

    end;

end;

O código acima percorre a lista de componentes da tela e usa a palavra chave IS para saber se o componente atual é do tipo TLabel (ou uma herança dessa classe). Em caso positivo, é feito um cast usando o AS e, então, as propriedades relacionadas ao fonte podem ser configuradas à vontade.

O recurso de uma linguagem de programação que permite obter informações sobre tipos de dados em tempo de execução é chamado de RTTI (Run Time Type Information). Em alguns ambientes, isso também é chamado de Reflexion.

Todos os objetos em Delphi conseguem reportar informações básicas sobre si mesmos, como o nome da classe a que pertencem, de qual classe ela herda, se implementa um determinado método, entre outros.

No entanto, a versão 2010 do Delphi passou por uma grande reformulação no tratamento de RTTI, aumentando significativamente sua capacidade. Agora você também pode obter informações sobre tipos atômicos, além de poder levantar os métodos e propriedades de classes, mesmo aqueles que sejam protegidos ou privados. Também é possível personalizar o RTTI, disponibilizando outras informações e funcionalidades a classes Delphi.

O novo mecanismo é baseado no conceito de "contexto", que nada mais é que o escopo constituido pelo programa principal, as bibliotecas (DLLs) e pacotes agregados. Toda aplicação Delphi passa a ter um único contexto RTTI onde são lançadas as informações sobre os tipos de dados em uso. Com isso, o primeiro passo para se obter informações sobre tipos é declarar e instanciar um contexto.

var lContexto: TRttiContext;

    lType: TRttiType;

    lMetodo : TRttiMethod;

    lParm : TRttiParameter;

begin

  lContexto := TRttiContext.Create;

  lType := lContexto.GetType(TypeInfo (TForm1));

  for lMetodo in lType.GetMethods() do begin

    ListBox1.AddItem(lMetodo.Name, lMetodo);

    for lParm in lMetodo.GetParameters () do

      ListBox1.AddItem('   ' + lParm.ToString (), lParm);

  end;

  lContexto.Free;

end;

Após instanciar o contexto, esse trecho de código obtém informações sobre o Form atual em dois passos. No primeiro, a função TypeInfo retorna um ponteiro para as informações básicas. Então, o ponteiro é usado num segundo passo para obter as informações extendidas que foram introduzidas na nova versão do RTTI e que são representadas pela classe TRttiType.

Em seguida, o código percorre a lista de métodos do Form1 - incluindo toda a hierarquia de classes a qual ele pertence - e adiciona seus nomes num list box para exibição. Para cada método também é recuperada a lista dos parâmetros que devem ser passados quando ele for chamado em seu programa.

Embora não esteja representado no exemplo, o mesmo tipo de levantamento pode ser feito com as propriedades, ainda que elas não estejam declaradas como published.

A dúvida mais frequente sobre esse tipo de recurso é: em que situações isso pode ser aplicado ? Além do cenário citado no início do post, outras situações podem ser mais facilmente resolvidas com RTTI, tais como a clonagem de objetos (incluindo o estado completo dele), serialização de objetos (transformá-los em um XML ou enviá-los para a impressora, por exemplo), criação de uma infraestutura para aceitar plugins em uma aplicação, chamada dinâmica de métodos, etc.

O próprio IDE do Delphi usa aspectos do RTTI para poder trabalhar com as classes e Forms que você desenvolve, fornecendo informações, por exemplo, para o Code Insight ou serializando a estrutura do Form em um arquivo DFM.

No próximo post, mostro o recurso que permite incrementar as informações de runtime em classes, métodos e propriedades.

Mais Informações
Working with RTTI

Preparando o Certificado Digital para inclusão no XML com CAPICOM e Delphi

2012-05-16T11:59:00.001-03:00

Há algum tempo, publiquei uma série de posts sobre a manipulação de XMLs e a criação de assinatura digital para eles. Como a plataforma .NET da Microsoft traz classes prontas para realizar o grosso das tarefas envolvidas, eu usei o C# para montar os exemplos contidos naqueles posts.

Mas muita gente não pode usar a solução com .Net, principalmente quem já têm aplicações desenvolvidas em outras linguagens. Algumas dessas pessoas entraram em contato pra saber como fazer esse mesmo procedimento usando a biblioteca de criptografia da Microsoft - o CAPICOM. Uma dúvida bastante frequente é relativa ao conteúdo a ser inserido na tag X509Certificate do XML assinado. O quadro abaixo mostra o trecho de um XML assinado de Nota Fiscal Eletrônica que inclui a tag em questão:

<?xml version="1.0" encoding="UTF-8" ?>

<enviNFe versao="2.00" xmlns="http://www.portalfiscal.inf.br/nfe">

<idLote>71</idLote>

<NFe>

<infNFe Id="NFe3508059978" versao="2.00">

 <cUF>35</cUF>

 <cNF>518005127</cNF>

 <natOp>Venda a vista</natOp>

 <mod>55</mod>

 <serie>1</serie>

 <dEmi>2012-05-06</dEmi>

 <tpAmb>2</tpAmb>

</infNFe>

<Signature>

<SignedInfo>
<CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>

<Reference URI="#NFe3508059978"

<Transforms>

<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>

<Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

</Transforms>

<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>

<DigestValue>4aXU7m8rl14ALy6X...=</DigestValue>

</Reference>

</SignedInfo>

<SignatureValue>Igq7eI/Fy3PyjjSW...=</SignatureValue>

<KeyInfo>

<X509Data>

<X509Certificate>MIIGxDCCBaygAwIBAgIIN6q4...=</X509Certificate>

</X509Data>

</KeyInfo>

</Signature>

</NFe>

  </enviNFe>

Como podemos ver, a tag X509Certificate é parte da estrutura que traz as informações sobre a chave usada pela assinatura e é incluída no fim do XML, junto com a área reservada para a assinatura em si. O valor armazenado na X509Certificate descreve o certificado usado na assinatura, codificado na Base64. Esse valor representa a chave do certificado e é parte imprescindível para a validação do documento XML, isso é, ele ajuda a garantir que o XML não foi adulterado depois de ter sido assinado.

E como calcular esse valor com CAPICOM? Após recuperar o certificado digital de acordo com as instruções do post Acessando o Certificate Store do Windows com CAPICOM, podemos conseguir o conteúdo desse certificado já na Base64 em um único comando:

var cert : TCertificate;

    certBase64 : WideString;

begin

  { ... }

  certBase64 := cert.Export(CAPICOM_ENCODE_BASE64);

  { ... }

A função export da interface ICertificate2 aceita como parâmetro o tipo de codificação que se deseja como resultado da exportaçao. Os valores permitidos para esse parâmetros são os definidos no tipo enumerado CAPICOM_ENCODING_TYPE. Ele pode assumir basicamente dois tipo de codificação : a Base64 ou a informação binária pura, sem codificação.

O código utilizado no exemplo - CAPICOM_ENCODE_BASE64 - faz a exportação de todas as informações necessárias para inclusão na tag X509Certificate do XML assinado. Há, no entanto, um detalhe no qual é preciso prestar atenção: o texto exportado está quebrado em diversas linhas.

MIIGNjCCBR6gAwIBAgIITDgm4uwI+60wDQYJKoZIhvcNAQEFBQAwTDELMAkGA1UE

BhMCQlIxEzARBgNVBAoTCklDUC1CcmFzaWwxKDAmBgNVBAMTH1NFUkFTQSBDZXJ0

aWZpY2Fkb3JhIERpZ2l0YWwgdjEwHhcNMTEwNzA3MTMxMDA0WhcNMTIwNzA2MTMx

MDA0WjCB7jELMAkGA1UEBhMCQlIxEzARBgNVBAoTCklDUC1CcmFzaWwxFDASBgNV

BAsTCyhFTSBCUkFOQ08pMRgwFgYDVQQLEw8wMDAwMDEwMDE5NjExNzIxFDASBgNV

BAsTCyhFTSBCUkFOQ08pMRQwEgYDVQQLEwsoRU0gQlJBTkNPKTEUMBIGA1UECxML

.

.

.

aXRhbC5jb20uYnIvc2VyYXNhY2R2MTANBgkqhkiG9w0BAQUFAAOCAQEAY8NBFO6e

kPTHirS8DHnlsx1kTJfmsHoUR1QgnDMNdChQjW7ctAn5nIpPYXdhf26om+Us80D/

5RA2iXHhXFT5eL7Crqq0DQ73zWbdn8e81dIDFqYjxIt4LBMy4CO0lJeiT9YHkmYB

XSuADpElqwXA0rzx7bBeIOzuVUGMoYQBduViByI813XIQ2i86Z9VgRLO5KuPUNPn

0RkZS2rSpX1/wLkef8ura++dZEYmbVWpu3g2yCLQJfCArYy/fzsIDwBKruSWnY/O

NK/1AgUaceVAcxxvVmuECwCBqtpfmHqAOXC/uEOXiKefF7L++j0Xc+Okew1SMkHJ

sNNJ+AcX4VfQrw==

Como o conteúdo da tag X509Certificate deve estar numa única linha, o texto retornado pelo export deve ser tratado, removendo-se os espaços em branco do fim e as quebras de linha:

   certBase64 := Trim (ReplaceStr (certBase64, #13#10, ''));

O valor da variável certBase64 agora pode ser incluído sem problemas como conteúdo da tag X509Certificate em seu XML assinado.

Mais Informações
Posts sobre CAPICOM, Função ICertificate2::Export

Trabalhando com HTTP em Delphi

2012-05-03T17:23:00.000-03:00

O protocolo HTTP - HyperText Transfer Protocol ou Protocolo de Transferência de Hipertexto) - é certamente o mais utilizado na internet. É com ele que as páginas da internete são transferidas para seu computador antes de serem exibidas no navegador. O termo "hipertexto" diz respeito ao fato de que os documentos obtidos através do protocolo podem conter links remetendo a outros documentos.

Numa primeira olhada, a utilidade do HTTP não parece muito diferente do FTP usado para fazer downloads. O código abaixo, por exemplo, obtém o documento padrão do site do Google Brasil, isto é, a página HTML que é exibida quando se digita o endereço do Google Brasil num navegador. No exemplo, estou usando o componente TIdHTTP da paleta do projeto Indy:

var lResponse : TStringStream;

begin

  lResponse := TStringStream.Create('');

  try

    { lResponse conterá a página HTML requisitada :}

    idHttp1.Get('http://www.google.com.br', lResponse);

  finally

    lResponse.Free();

  end;

Apesar de não ser necessário configurar explicitamente um servidor/porta e usuário/senha como no FTP, o resultado final é o mesmo: o download de um arquivo remoto. Na verdade, a infraestrutura da internete mapeia automaticamente o endereço do Google para um servidor/porta; nesse caso, o usuário e senha é dispensável pois se trata de um site público que permite acesso anônimo.

Se olharmos mais a fundo, no entanto, veremos que o HTTP é mais flexível porque permite adicionar parâmetros à requisição enviada ao servidor. Na prática, isso dá ao servidor a chance de montar dinamicamente a resposta mais adequada à solicitação feita. As APIs de serviços publicados na internete normalmente são baseados no HTTP e se valem dos parâmetros pra flexibilizar as requisições. É o caso, por exemplo, do Google Docs e de outros serviços do Google, que usam a API de dados da empresa. Em outro post, eu mostro como se comunicar com o Google Docs usando a API de dados para ler os documentos salvos nesse serviço.

Se você já trabalhou com HTML, deve ter notado que a sintaxe dos Forms inclui uma "action", um método de envio e os diversos campos que serão preenchidos pelo usuário da página, sendo admitido até mesmo a existência de campos invisíveis contendo informações pré alimentadas.

Para relembrar o significado dessas propriedades do Form HTML : A "action" é o endereço na internete para onde a requisição será submetida. O "método" diz repespeito a como e quais informações serão enviadas; os valores mais comuns são GET (as informações são formatadas e acrescentadas ao endereço da "action", que então é enviado ao servidor) ou POST (as informações são transportadas à parte e não é possível enxergá-las na barra de endereço do navegador).

O form de pesquisa do Google, por exemplo, admite que você selecione a língua na qual deseja obter as repostas e, claro, os termos a serem pesquisados. O exemplo abaixo submete ao Google uma pesquisa em português com o nome do blog:

var lURL : String;

    lResponse : TStringStream;

begin

  lResponse := TStringStream.Create('');

  try

    lURL := 'http://www.google.com.br/search?' +

            'hl=pt-BR&' +

            'q=balaio%20tecnologico';

    idHttp1.Get(lURL, lResponse);

    lResponse.Position := 0;

    { Exemplo de uso do response : carregar o conteúdo  num RichEdit : }

     reResp.Lines.LoadFromStream(lResponse);

  finally

    lResponse.Free();

  end;

Veja que cada parâmetro é composto de um nome (o mesmo configurado nas tags input do form) seguido por um sinal de igual (=) e o valor que o parâmetro deve assumir (normalmente, os próprios valores fornecidos pelo usuário). Cada parâmetro é concatenado ao anterior através de um "E Comercial" (&).

Ambos os parâmetros considerados pelo exemplo estão incluídos no form da pesquisa do Google. Ou seja, se você souber quais são os parâmetros de um form, poderá simular via Delphi a requisição que ele submeteria numa página da Web e, então, obter exatamente a mesma reposta, podendo tratá-la do modo que for mais apropriado para sua aplicação.

Por causa dessa facilidade de simular requisições via programação, muitos sites se protegem implementando um CAPTCHA. Trata-se de uma imagem com um texto embutido que é gerada dinamicamente pelo servidor de modo que apenas operadores humanos consigam ler. O texto deve, então, ser digitado num campo e enviado junto com as demais informações. A requisição só é atendida se o texto estiver correto.

Como podemos notar pelo exemplo, usar o GET para recuperar um documento pode ser problemático se certas informações sensíveis - como uma senha - tiverem que ser transmitidas direto na URL. Nestes casos, é recomendado usar o POST pois com ele as informações trafegam por outros meios.

O uso do POST também é simples. Basta passar os parâmetros num TStringList separado. A URL do "action" é informada sem quaisquer decorações extras:

var lParams :TStringList;

lResponse : TStringStream;

begin

  lParams := TStringList.Create;

  lResponse := TStringStream.Create('');

  try

    lParams.Add('filt=all');

    lParams.Add('p=balaio%20tecnologico');

    idHttp1.Post('http://br.search.yahoo.com/search', lParams, lResponse);

    { Exemplo de uso do response : carregar o conteúdo  num RichEdit : }

    lResponse.Position := 0;

     reResp.Lines.LoadFromStream(lResponse);

  finally

    lParams.Free();

    lResponse.Free();

  end;

Neste exemplo, usei o Yahoo! porque o Google não implementa POST para pesquisas.

Ajustes ainda mais finos para submeter a requisição podem ser configuras na propriedade Request do TIdHTTP. Com ele, é possível ajustar o tipo de documento que se espera receber de volta (HTML, XML, etc.), o tipo de encoding, se há necessidade de passar por um proxy, etc.

Mais Informações
Protocolo HTTP, Tag Form do HTML, CAPTCHA

Novo IPad complica a vida dos desenvolvedores HTML5

2012-04-11T16:40:00.001-03:00

Se você já achava dura a vida de desenvolvedor HTML, com as muitas diferenças de implementação nos diversos navegadores e a infinidade de tamanhos de telas disponíveis em desktops, tablets e celulares, veja só essa matéria publicada na InfoWorld sobre os teste feitos com os recursos do novo tablet da Apple - o iPad 3.

O novo iPad da Apple, já um sucesso entre os consumidores com sua tela de alta resolução, está, no entanto, decepcionando alguns desenvolvedores HTML5. O sistema operacional do tablet - iOS 5.1 - complica o armazenamento de dados do HTML5, não oferece novos suportes ao HTML5 e a performance na navegação web é, na melhor das hipóteses, similar à do iPad 2.

É demais classificar isso de "retrocesso" e ninguém está dizendo que a Apple está recuando de seu apoio agressivo aos padrões na web, o que eventualmente deixará aplicações web com comportamento próximo ao das aplicações nativas. Mas, para alguns, as decisões da Apple comprometem e poderiam viver sem elas.

A Sencha, fornecedora de ferramentas para HTML5, postou na semana passada uma "Avaliação HTML5' para o novo iPad e o iOS 5.1, classificando os resultados como um "saco misto" para a Apple. A avaliação do fornecedor pesou dois critérios: completude –- quanto dos vários elementos do HTML5 estão presentes –- e correção –- se o suporte a esses elementos está bem implementado, diz Aditya Bansod, diretor senior e gerente de produto da empresa de software sediada em Redwood City, Califórnia. O post também inclui resultados de comparativos com outros produtos em relação à performance do tablet na navegação.

"Ainda é a melhor plataforma HTML5 no mercado", diz Bansod. "Mas esperávamos um avanço maior que este (no novo iPad). Ao invés disso, estamos pisando em terreno pantanoso e até mesmo retrocedemos um pouco. É um tanto desapontador por parte da Apple."

Complicando o armazenamento de dados Web
Uma mudança, introduzida primeiro em 2011 com uma distribuição beta do iOS 5.1, limita alguns aspectos do armazenamento de dados local do HTML5. Dados armazenados localmente usando o LocalStorage do HTML5 não são mais tratados como persistentes pelo sistema operacional. Isto introduz um problema para desenvolvedores que usam este recurso para armazenar dados locais ou o WebSQL como mecanismo de armazenamento. Como o sistema não enxerga mais esses dados como persistentes e sim como temporários, "o iOS pode removê-los a qualquer momento, sem aviso, até em cenários onde o sistema está com pouca memória disponível", anotou Bansod em seu post.

Os desenvolvedores web rapidamente captaram a mudança em janeiro, discutindo-a em vários foruns online, como o forum Phonegap no Google Groups.

O problema afeta um sub grupo de aplicações do iOS, às vezes chamadas de aplicações híbridas, que utilizam uma WebView embutida. "WebViews são a força das aplicações HTML5 inseridas em pacotes nativos, como os do PhoneGap ou do Sencha Touch," escreveu Bansod. "Elas embutem um navegador web em aplicações nativas, o que permite a distribuição de aplicações web através das App Stores nativas. WebViews estão presentes em todos os sistemas operacionais mobile modernos."

Até o iOS 5.1, aplicações WebView podiam armazenar dados localmente e persistí-los usando o armazenamento do HTML5. "Especificamente, se sua aplicação usava LocalStorage ou WebSQL, isso era considerado parte dos dados da aplicação," diz Bansod. Se uma nova versão da aplicação fosse lançada, os dados ainda estariam presentes.

Este não é mais o caso. "É possível que isso se dê porque a Apple não conseguiu fazer de forma confiável a sincronização de dados pelo iCloud quando esses dados não estão armazenados no sistema de armazenamento nativo do iOS." especula Bansod. Um desenvolvedor disse no forum do Phonegap que ele foi informado por alguém da Apple que a razão para a mudança era "para economizar espaço, pois aplicações carregando muito conteúdo numa UIWebView (como o Twitter) ocuparia espaço demais [na sincronização com o serviço iCloud da Apple]... Mas eles esqueceram completamente de nós, pobres desenvolvedores Phonegap, que contavam com o LocalStorage ou o WebSQL para armazenar os dados dos usuários."

"Para os desenvolvedores que contavam com o LocalStorage ou o WebSQL como mecanismo para armazenar dados de suas aplicações, interrompê-lo é um grande problema," disse Bansod em seu post. Não é impeditivo: "Há vários meios de contornar o problema, como usar o SQLPlugin do PhoneGap que usa o SQLite padrão, or escrever seu próprio JavaScript para acessar diretamente o CoreData do iOS." Para muitos, afirma ele, isso significa recodificar suas aplicações.

De fato, aplicações que não forem alteradas "esquecerão" os dados. Os usuários também podem perder dados já que aplicações nas quais eles costumavam armazenar dados relevantes, de repente deixaram de fazer esse armazenamento, por exemplo.

Ao menos alguns desenvolvedores têm a esperança de que esta mudança seja apenas um bug que a Apple corrigirá. Em 7 de Março, com o anúncio do novo iPad e o iOS 5.1, eles descobriram que a Apple os colocou num novo território. "Eles fizeram isto. A Apple lançou o programa com aquele bug. Eu já tenho usuários furiosos porque perderam seus trabalhos com minha aplicação. :-/," postou Sam no forum do Phonegap.

As formas de contornar o problema não são simples, como se vê ao acompanhar as discussões para um plugin do Phonegap, criado por Shazron Abdullah na Apache Software Foundation.

Sem avanços nos recursos do HTML5
A avaliação da Sencha também revelou a ausência de quaisquer novas funções HTML5 no iOS 5.1 e na novíssima versão mobile do navegador Safari da Apple. "Nenhum novo recurso apareceu entre as versões iOS 5.0 e iOS 5.1," escreveu. "O iOS ainda apresenta um dos melhores suportes ao HTML5 entre os navegadores mobile, mas esta última encarnação não aprofundou o suporte do Safari aos padrões."

O Safari 6 no Mac, por exemplo, suporta um recurso chamado Regiões de Cascading Style Sheets (CSS), um modo simples de criar e modificar o layout de revistas digitais. Mas está faltando na versão atual do Safari para dispositivos com iOS 5.1.

"Queríamos ver também se o WebGL [uma API JavaScript para desenhar gráficos em 3D sem a necessidade de um plugin], que atualmente é suportado somente no Apple iAds, está disponível no navegador," Bansod escreveu. "haz.io [um site que avalia se seu navegador suporta padrões web emergentes] reporta que o WebGL é suportado pela versão mobile do Safari, mas, quando usamos o repositório de exemplos Khronos para testar, foi impossível fazer com que algum dos exemplos funcionasse."

Performance web
Para avaliar a performance web do novo iPad, a Sencha executou um conjunto de testes comparativos específicos da web usando um novo iPad, um iPad 2 (ambos com iOS 5.1), um tablet Motorola Xoom com Android 3.0, e um RIM PlayBook com Tablet OS 1.0. A equipe de Bansod executou o teste SunSpider e o V8 Benchmark Suite para medir o poder de processamento de códigos JavaScript.

Como é sabido, o novo iPad usa uma versão do chip dual-core A5 da Apple, com um novo processador gráfico quadcore.

No geral, o novo iPad (apelidado "Retina iPad" nos resultados dos testes da Sencha) foi um pouco mais lento em 6 dos 9 testes SunSpider. Nos sete testes do V8, o novo iPad empatou com o iPad 2 mas ambos perderam do tablet da Motorola.

Segundo Bansod, em muito da navegação pela internet, os usuários do novo iPad não verão problemas. Mas a diferença entre os dois iPads é perceptível quando se trata de desenhar páginas complexas. Por exemplo, o novo iPad estava visivelmente carregando novos blocos na parte de baixo de uma página de exemplo enquanto a página era rolada, coisa que raramente ocorria com o iPad 2.

Ele especula que uma razão para o patamar de desempenho do novo iPad é que a Apple acrescentou o processador gráfico quad-core e mais memória, mas não tornaram a memória mais rápida. Isso significaria, diz ele, que jogar imagens e outros recursos gráficos para a GPU está consumindo mais tempo e banda do que o dispositivo pode manipular em tempo real.

A matéria original em inglês pode ser acessada neste link.

Mais Informações
New iPad complicates life for HTML5 developers

Preparando aplicações Delphi para requerer incremento no Nível de Execução

2012-04-03T14:02:00.000-03:00

Desde o Windows XP, a Microsoft vem implementando medidas que dificultam o acesso não autorizado a certos recursos do sistema, como o Registry, por exemplo. O intuito é incrementar a segurança do sistema operacional, evitando seu comprometimento ou até mesmo o roubo de informações. Esse esforço foi mais notado no Windows Vista, quando foi introduzido o UAC (User Account Control) para solicitar ao usuário permissão para acessar os recursos.

Com essa mudança, programas que antes liam tranquilamente o registro do Windows deixaram de funcionar. Dependendo de como o programa foi implementado, a exceção levantada pela falta de privilégio de acesso ao recurso pode até mesmo derrubar a aplicação com mensagens de erro pouco amistosas. O quadro abaixo traz um exemplo de código em Delphi que executa sem problemas no XP mas que não funcionará no Vista e no Win7 - a menos que o usuário comande a execução como Administrador:

procedure TForm1.BitBtn1Click(Sender: TObject);

var lReg: TRegistry;

begin

  lReg := TRegistry.Create();

  try

    lReg.RootKey := HKEY_LOCAL_MACHINE;

    lReg.OpenKey('Software\empresa', true);

    lReg.WriteString('TipoImpressora', '0');

    Application.MessageBox('Opção gravada com sucesso', 'Aviso', MB_OK);

  except

    on Erro: Exception do

      Application.ShowException(Erro);

  end;

  lReg.Free;

end;

Felizmente, há um meio de informar ao sistema operacional que uma operação dessa natureza vai ocorrer e que, portanto, o usuário necessitará obrigatoriamente de privilégios de administrador para executar o programa. Esse processo é chamado de Requisição de Elevação do Nível de Execução e é feito através de um arquivo de manifesto que deve ser linkado junto com a aplicação.

O manifesto é um arquivo XML com estrutura bem definida, como a mostrada no quadro abaixo:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">

<assemblyIdentity

    name="ABC71.TesteManifest"

    processorArchitecture="x86"

    version="1.0.0.0"

    type="win32"/>

<v3:trustInfo xmlns:v3="urn:schemas-microsoft-com:asm.v3">

    <v3:security>

      <v3:requestedPrivileges>

        <v3:requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>

      </v3:requestedPrivileges>

    </v3:security>

</v3:trustInfo>

<description>TesteManifest</description>

</assembly>

O manifesto é composto de duas partes obrigatórias. O assembly é o nó raiz do XML, usado para aninhar as demais tags com as configurações em si. A tag interna assemblyIdentity identifica nossa aplicação, armazenando um nome único para ela e informando sua versão e a arquitetura para a qual ela foi desenhada. No exemplo, vemos que a nossa aplicação é Win32 e roda em processadores x86.

As outras tags são opcionais mas o nosso exemplo inclui também a tag v3:trustInfo, que é onde registramos a requisição do incremento de nível de execução. Tal requisição é feita no parâmetro level da tag requestedExecutionLevel, seguindo a estrutura mostrada acima. Quando informamos o valor requireAdministrator em level estamos dizendo ao Windows que o programa só pode executar se tiver privilégios de administrador. Então, antes de executá-lo, o Windows apresentará a tela para que o usuário forneça as credenciais do administrador - nome e senha - e só prosseguirá se elas estiverem corretas.

Para que essa configuração tenha efeito, precisamos criar um arquivo de recursos que aponta o manifesto e então, linká-lo ao programa Delphi. Um arquivo de recursos é um repositório onde são indicadas informações a serem agregadas a um programa, permitindo adicionar desde ícones e cursores até blocos de texto e dados binários para uso da aplicação. O arquivo de recurso pode ter extensão RC (quando é somente um texto) ou RES (resultado da compilação do RC). Supondo que o arquivo de manifesto se chame manifesto.manifest, um arquivo RC pode ser montado assim:

#define MANIFEST_RESOURCE_ID 1

MANIFEST_RESOURCE_ID 24 manifesto.manifest

O número 24 nesse arquivo indica ao Windows que o recurso em questão é um arquivo de manifesto. O arquivo RC deve ser adicionado ao projeto do Delphi e o arquivo de manifesto deve estar disponível na mesma pasta. Lembre-se que o Delphi cria automaticamente um arquivo RES com o mesmo nome do projeto; então, escolha um nome diferente do projeto para o RC extra.

Essa requisição de elevação de nível é especialmente útil em programas para configuração ou instalação de sistemas, situações que geralmente exigem privilégios mais altos para acesso a recursos protegidos, mais sensíveis. Na verdade, arquivos de manifesto são mais complexos do que o que foi apresentado aqui, servindo também para indicar se uma aplicação utilizará temas do Windows, se essa aplicação tem dependências de bibliotecas externas, entre outras coisas. O MSDN documenta o conteúdo permitido para esses arquivos neste link.

Versões mais recentes do Delphi permitem utilizar temas na criação de aplicações e, por isso, elas embutem automaticamente um manifesto em cada projeto. Assim, para conseguir inserir a requisição de incremento do nível de execução nestas versões, é preciso modificar a configuração do projeto, pedindo que se considere um arquivo de manifesto externo ao invés daquele que vem por padrão. Na página de configuração da aplicação - a mesma onde se muda o ícone do seu programa, selecione a opção "Use Custom Manifest" na caixa Runtime Themes. Depois, informe o caminho do seu arquivo de manifesto na caixa Custom Manifest, logo abaixo.

Mais Informações
Create and Embed an Application Manifest (UAC), Referência de Arquivos de Manifesto para Aplicações, User Account Control

Trabalhando com rotinas T-SQL no SQL Server

2012-03-23T13:11:00.000-03:00

O SQL (Structured Query Language) é muito mas que apenas uma linguagem para manutenções num banco de dados. Ela não se restringe às quatro operações básicas (INSERT, DELETE, UPDATE e SELECT) ou àquelas funções para gerenciar tabelas ou transações. O SQL Server da Microsoft, por exemplo, implementa uma extensão do padrão SQL chamada T-SQL (Transact SQL) que permite construir funções complexas. Elas combinam queries com elementos típicos das linguagens de programação comuns, fornecendo uma sintaxe que inclui variáveis, loops e controle de fluxo.

Com essa linguagem, você pode construir Triggers, Stored Procedures, Functions ou simplesmente executar comandos pelo SQL Server Management Studio (função antigamente disponível no Query Analyser). Neste post, vou usar essa ferramenta para mostrar alguns dos recursos do T-SQL.

Para montarmos o exemplo básico, considere que vamos gerar uma lista de preços baseada nas informações contidas numa tabela chamada LISTAPR, criada de acordo com o comando a seguir:

-- Em SQL Server

create table LISTAPR
(

ID int not null,

PRODUTO varchar(25) null,

DESCRICAO varchar(255) null,

PRECO numeric(15,4) null,

DATA_VLD smalldatetime null

)

Como toda linguagem, o T-SQL possui comandos de declaração de variáveis para armazenar valores ao longo do programa. Basicamente, os tipos de dados permitidos são os mesmos que são válidos para criação de campos num tabela, com exceção dos tipos que representam BLOBs (text, ntext e image). A declaração em si é feita com a palavra chave DECLARE seguida de um arroba (@) acompanhando o nome da variável e, para finalizar, o tipo de dado que essa variável será capaz de armazenar. Exemplos:

DECLARE @produto varchar(25)

DECLARE @descricao varchar(255)

DECLARE @preco numeric(15,4)

DECLARE @linha varchar(300)

DECLARE @nro_regs int

SELECT @nro_regs = 0

A forma como os valores são recuperados do banco de dados nos obriga a declarar variáveis para os campos que pretendemos manipular. Assim, no trecho acima eu declarei uma variável para cada campo que será impresso. Como se vê também, o comando SELECT pode ser usado para atribuir manualmente valores para as variáveis.

Há um tipo especial de variável para ser usado na obtenção de um result set (lista de registros). O nome desse tipo é CURSOR e é através dele que estabelecemos quais dados serão recuperados do banco, qual o tipo de navegação será permitida nos registros (apenas avançar ou ir pra frente e pra trás) e também se será possível atualizar os dados. Para o cenário proposto neste post, precisaremos de uma coleção read-only que contenha todos os registros da tabela LISTAPR que estejam dentro da validade. A declaração abaixo atende esses requisitos:

DECLARE lista CURSOR SCROLL FOR

  SELECT produto, descricao, preco

  FROM LISTAPR

  WHERE DATA_VLD > GETDATE() OR DATA_VLD IS NULL

O tipo da navegação é irrelevante aqui mas eu inclui a palavra SCROLL na declaração, possibilitando a navegação pelos registros em qualquer direção que queiramos. Outro detalhe é que eu estipulei quais campos eu quero recuperar. Isso é uma boa prática pois, conforme veremos adiante, deixa claro quais campos corresponderão a quais variáveis.

Agora, podemos abrir o cursor criado, navegar pela lista de registros obtidos, processar os dados conforme necessário e, finalmente, encerrar o cursor. O quadro abaixo traz o código com os passos citados:

OPEN lista

-- Primeiro registro

FETCH FIRST FROM lista INTO @produto, @descricao, @preco

WHILE @@FETCH_STATUS = 0

BEGIN

  -- O processamento do registro atual será feito aqui

  -- Próximo registro

  FETCH NEXT FROM lista INTO @produto, @descricao, @preco

END

CLOSE lista

DEALLOCATE lista

Vamos destrinchar esse código. O comando OPEN apenas abre o cursor, submetendo a query ao banco de dados. O comando FETCH FIRST posiciona no primeiro registro e transfere para as variáveis os valores obtidos. Veja que a ordem das variáveis na cláusula INTO segue a mesma ordem estabelecida na cláusula SELECT.

A instrução WHILE é um laço tradicional, repetindo os comandos entre o BEGIN e o END enquanto o valor da expressão após o WHILE for verdadeira. Neste caso, @@FETCH_STATUS é uma variável nativa do T-SQL. Ela é afetada pela execução de comandos FETCH, assumindo valor 0 (zero) quando há um registro válido posicionado. Com isso, o comando FETCH NEXT, é executado enquanto ainda houver registros a recuperar no cursor.

Para encerrar, o cursor é fechado com o comando CLOSE e os recursos usados por ele são devolvidos ao sistema através do comando DEALLOCATE. Variáveis do tipo CURSOR são as únicas que requerem a desalocação explícita.

Ficou faltando a parte do processamento interno do laço. Como planejamos simplesmente imprimir os valores das variáveis, podemos usar o comando PRINT para isso. Ele aceita um texto como parâmetro, de modo que teremos que fazer a conversão dos tipos numéricos antes de imprimir.

  SELECT @nro_regs = @nro_regs + 1,  @linha = ''

  SELECT @linha = @linha + @produto + REPLICATE (' ', 21 - LEN (@produto))

  SELECT @linha = @linha + @descricao + REPLICATE (' ', 21 - LEN (@descricao))

  SELECT @linha = @linha + STR (@preco, 10, 2)

  PRINT @linha

Cada chamada ao PRINT gera uma nova linha na janela de saída do Management Studio, razão pela qual concateno os valores num único texto antes de imprimí-lo. Assim, cada produto terá sua própria linha. A ginástica com o REPLICATE e o LEN é para garantir que produto e descrição apareçam sempre com a mesma quantidade de caracteres, mantendo o resultado alinhado, mais fácil de ler. O STR converte o preço em um texto para a impressão.

É claro que, dada a simplicidade do exemplo, poderíamos ter resolvido o problema apenas executando a query. Mas o objetivo aqui era mostrar a flexibilidade da linguagem já que ela permite conter cursores aninhados, trabalhar com decisões de fluxo (instrução IF), cálculos complexos e outras interações. Aqui na ABC71, nós aproveitamos essa flexibilidade do T-SQL mesclada a queries que obtêm informações sobre tabelas do banco de dados para gerar certos tipos de codigo fonte auxiliares de nosso ERP.

Mais Informações
Transact SQL, Funções nativas T-SQL para SQL Server 2008

Design Patterns com Delphi: Visitor - Parte II

2012-03-13T17:42:00.003-03:00

No último post, eu apresentei o conceito do Design Pattern Visitor usando para isso um diagrama UML com um exemplo prático da aplicabilidade do padrão. O exemplo consiste na representação de um Produto Acabado composto por uma lista de recursos (as matérias primas, máquinas e instruções) usados para fabricá-lo. O objetivo é permitir aplicar ao produto operações externas cujo resultado depende da aplicação da operação em cada parte que compõe a estrutura. No exemplo, há duas operações: uma que exporta a arquitetura do produto em formato XML e outra que faz a impressão dessa estrutura.

Neste post, mostro uma sugestão de implementação em Delphi para o exemplo do Visitor. Para facilitar a referência, publico novamente o diagrama que o retrata:

O primeiro passo é definir as classes que representam o propósito do sistema, estabelecendo as regras de negócio que constituirão o cerne dele. No nosso caso, essas classes são o recurso de produção, suas heranças e o produto acabado. O quadro abaixo mostra as declarações delas, que são bastante simples :

  { Recursos para a produção }

  TWRecursoProducao=class

  public

    _Nome: String;

    Constructor Create (ANome: String);virtual;

    procedure Accept (AOper: TWOperacoesPA);virtual;

  end;

  TWMateriaPrima=class(TWRecursoProducao)

  public

    _CProd: String;

    _Qtde: Double;

    Constructor Create (ANome: String);override;

    procedure Accept (AOper: TWOperacoesPA);override;

  end;

  TWMaquina=class(TWRecursoProducao)

  public

    _Cod: String;

    _Tempo: Double;

    _TempoSetup: Double;

    Constructor Create (ANome: String);override;

    procedure Accept (AOper: TWOperacoesPA);override;

  end;

  TWRoteiro=class(TWRecursoProducao)

  public

    _Cod: String;

    _Texto: String;

    Constructor Create (ANome: String);override;

    procedure Accept (AOper: TWOperacoesPA);override;

  end;

  { Produto Acabado }

  TWProdutoAcabado=class

  protected

    _MatPrimas : TObjectList;

    _Maquinas : TObjectList;

    _Roteiro : TWRoteiro;

    procedure ClearListaRec (ALista: TObjectList);

  public

    _Nome: String;

    Constructor Create (ANome: String);

    Destructor Destroy; override;

    procedure ClearRecursos;

    procedure AddMatPrima (ARecurso: TWRecursoProducao);

    procedure AddMaquina (ARecurso: TWRecursoProducao);

    procedure SetRoteiro (ARoteiro: TWRoteiro);

    procedure DoOperacao (AOper: TWOperacoesPA);

  end;

Veja que a classe que representa o produto acabado (TWProdutoAcabado) possui membros do tipo TObjectList e também um roteiro separado. Esses membros armazenarão os recursos necessários para fabricar o produto acabado. Neste exemplo, as classes que compõem a agregação são heranças de uma mesma classe base - a TWRecursoProducao - mas o padrão Visitor não faz essa exigência. Assim, ele ainda é aplicável mesmo quando a agregação é composta por classes que não guardam relação entre si. Então, usei variáveis separadas pra cada tipo de recurso apenas para deixar clara essa possibilidade.

Repare ainda na função Accept introduzida na classe base de recursos. É ela quem define a família de classes como Visitable, determinando que os recursos de produção que elas representam poderão ser visitados por qualquer operação externa herdada de TWOperacoesPA. Na verdade, Accept simplesmente solicitará à operação que "visite" o recurso em questão, o que fará com que a operação seja aplicada ao recurso :

procedure TWMateriaPrima.Accept (AOper: TWOperacoesPA);

begin;

  inherited;

  AOper.Visit (Self);

end;

procedure TWMaquina.Accept (AOper: TWOperacoesPA);

begin;

  inherited;

  AOper.Visit (Self);

end;

procedure TWRoteiro.Accept (AOper: TWOperacoesPA);

begin;

  inherited;

  AOper.Visit (Self);

end;

A seguir, podemos definir a hierarquia de classes que implementarão as operações externas nos recursos de produção. Tais classes exercerão o papel de Visitors:

   TWOperacoesPA=class

  public

      procedure InitOper(AInfo: TObject);virtual;

      procedure TermOper;virtual;

      procedure Visit (pRecurso: TWMateriaPrima);overload;virtual;

      procedure Visit (pRecurso: TWMaquina);overload;virtual;

      procedure Visit (pRecurso: TWRoteiro);overload;virtual;

  end;

   TWRecursoSaveToXml=class(TWOperacoesPA)

  protected

      _Xml : String;

  public

      procedure InitOper(AInfo: TObject);override;

      procedure TermOper;override;

      procedure Visit (pRecurso: TWMateriaPrima);overload;override;

      procedure Visit (pRecurso: TWMaquina);overload;override;

      procedure Visit (pRecurso: TWRoteiro);overload;override;

      function GetXML : String;

  end;

A operação para imprimir o produto acabado é bastante similar à de salva para XML e, por isso, eu a omiti do quadro.

Veja que a classe TWOperacoesPA, que é base para todas as operações, possui 3 métodos Visit sobrecarregados (overload). Cada um deles trata um tipo diferente de recurso, o que, na prática, nos permite adequar o comportamento da operação. Isso quer dizer que a operação será realizada de um modo coerente com o tipo do recurso.

Um outro detalhe nessa classe é a função InitOper. Ela é desenhada para realizar procedimentos iniciais da operação, aceitando um parâmetro genérico do tipo TObject com informações que façam sentido para a operação. Por exemplo, pode representar uma impressora para a operação de Imprimir ou um objeto DOM para a exportação em formato XML.

O trecho de código abaixo mostra as funções de inicialização e encerramento da operação de exportação para XML. Também retrata a versão da função Visit sobrecarregada para os tipos de recurso "Matéria Prima" e "Máquina":

procedure TWRecursoSaveToXml.InitOper(AInfo: TObject);

var lProd: TWProdutoAcabado;

begin

  inherited;

  {Abre a tag raiz para o XML }

  lProd := AInfo   As TWProdutoAcabado;

  _XML := '<?xml version="1.0" encoding="ISO-8859-1"?>' + #13#10;

  _XML := _XML + '<produtoAcabado name="' + lProd._Nome + '">' + #13#10;

end;

procedure TWRecursoSaveToXml.TermOper;

begin

  { Fecha a tag XML raiz }

  _XML := _XML + '</produtoAcabado>';

  inherited;

end;

procedure TWRecursoSaveToXml.Visit (pRecurso: TWMateriaPrima);

begin

  inherited;

  { Versão específica dessa operação p/ o recurso "Matéria Prima" }

  _XML := _XML + '  <materiaPrima>' + #13#10;

  _XML := _XML + '    <codigo>' + pRecurso._CProd + '</codigo>' + #13#10;

  _XML := _XML + '    <nome>' + pRecurso._Nome + '</nome>' + #13#10;

  _XML := _XML + '    <qtde>' + FormatFloat ('#,##0.00', pRecurso._Qtde) + '</qtde>' + #13#10;

  _XML := _XML + '  </materiaPrima>' + #13#10;

end;

procedure TWRecursoSaveToXml.Visit (pRecurso: TWMaquina);

begin

  inherited;

  { Versão específica dessa operação p/ o recurso "Máquina" }

  _XML := _XML + '  <maquina>' + #13#10;

  _XML := _XML + '    <codigo>' + pRecurso._Cod + '</codigo>' + #13#10;

  _XML := _XML + '    <nome>' + pRecurso._Nome + '</nome>' + #13#10;

  _XML := _XML + '    <setup>' + FormatFloat ('#,##0.00', pRecurso._TempoSetup) + '</setup>' + #13#10;

  _XML := _XML + '    <tempo>' + FormatFloat ('#,##0.00', pRecurso._Tempo) + '</tempo>' + #13#10;

  _XML := _XML + '  </maquina>' + #13#10;

end;

Por fim, podemos implementar a função que aplica a operação ao produto acabado. Por definição, isso implica aplicar a mesma operação sobre os recursos que compõe esse produto acabado. Por isso, teremos que passar por todos os recursos, chamando a função Accept para determinar como a operação deve ser executada em cada um deles:

procedure TWProdutoAcabado.DoOperacao (AOper: TWOperacoesPA);

var i : integer;

lMatPrima: TWMateriaPrima;

lMaquina : TWMaquina;

begin

  AOper.InitOper (Self);

  { Aplica a operação a cada matéria prima da lista }

  for i := 0 to _MatPrimas.Count - 1 do

  begin

    lMatPrima := _MatPrimas.Items[i] As TWMateriaPrima;

    lMatPrima.Accept (AOper);

  end;

  { Aplica a operação a cada máquina da lista }

  for i := 0 to _Maquinas.Count - 1 do

  begin

    lMaquina := _Maquinas.Items[i] As TWMaquina;

    lMaquina.Accept (AOper);

  end;

  { Aplica a operação no roteiro, se houver um }

  if (_Roteiro <> Nil) then

    _Roteiro.Accept (AOper);

  AOper.TermOper;

end;

{ ... }

var lOperacao : TWRecursoSaveToXml;

lProd : TWProdutoAcabado;

lXml : String;

begin

  lProd := TWProdutoAcabado.Create ('Computador');

  lOperacao := TWRecursoSaveToXml.Create;

  lProd.DoOperacao(lOperacao);

  { Publica o resultado da operação }

  lXml := lOperacao.GetXML ();

{ ... }

end;

A parte inferior do quadro demonstra como se dá a aplicação de uma operação.

O projeto com esse exemplo pode ser salvo a partir desse link. Ele foi criado em Delphi 2005 mas deve ser possível compilá-lo em outras versões do IDE sem problemas.

Mais Informações
Design Patterns com Delphi: Visitor - Parte I, Posts sobre Design Patterns, Download do projeto do exemplo

Design Patterns com Delphi: Visitor - Parte I

2012-02-27T13:48:00.002-03:00

Coleções de objetos são uma das estruturas mais comumente usadas na construção de programas de computador. Elas podem aparecer na forma de listas, vetores ou em agregações e composições, onde diferentes tipos de objeto são mantidos juntos para representar um objeto mais complexo.

Um dos propósitos que nos leva a agruparmos objetos numa mesma estrutura é facilitar a execução de operações envolvendo as partes que constituem esse objeto. Ou seja, operações nas quais percorreremos todos os elementos e aplicaremos a cada um deles a operação desejada. Nesse processo, a existência de objetos de tipos distintos deve ser levada em conta porque uma mesma operação pode ter significado diferente, dependente do tipo de objeto. Isto nos leva a ter que escolher a versão correta da operação que deve ser executada em cada elemento. Por exemplo, considere que você tem uma classe representando a lista de recursos necessários para fabricar um produto. A lista inclui as matérias primas, as máquinas envolvidas e até roteiros descrevendo o processo de fabricação. Uma operação que imprima a estrutura terá que considerar as diferenças entre cada uma dessas partes pois elas têm informações específicas distintas.

Em princípio, parece que uma herança simples pode resolver a questão. Mas, e se for necessário acrescentar novos tipos de operação, com nomes e parâmetros diferentes - salvar em formato XML, por exemplo ? Teríamos que alterar a estrutura da agregação para que ela comporte a nova operação.

O intuito do Design Pattern comportamental Visitor é facilitar a manutenção desse tipo de estrutura heterogênea. Ele nos obriga a manter separada a estrutura de um objeto e os algoritmos das operações que podem ser aplicadas sobre seus componentes. Com isso, podemos introduzir novas operações à estrutura sem que seja preciso modificar as classes onde essas operações serão aplicadas. Em outras palavras, o que o Visitor propõe é transferir a implementação das operações, removendo-as das classes que compõem a agregação e passando-as para classes próprias. Com isso, preserva-se a estrutura original tanto da agregação quanto das partes que a compõem.

O diagrama abaixo mostra um exemplo prático da aplicabilidade desse padrão. Nele, um Produto Acabado é composto de uma lista de recursos, incluindo as matérias primas, máquinas e instruções para a fabricação dele. São definidas duas operações externas : uma para exportar a arquitetura do produto para XML e outra para imprimí-la.

De acordo com o papel que exercem na implementação de uma solução para o padrão Visitor, as classes envolvidas são formalmente conhecidas pelos nomes que seguem:

O Visitor é uma abstração que define quais classes de objetos poderão ser submetidas às operações que serão disponibilizadas. Ele faz isso ao introduzir métodos sobrecarregados, um para cada tipo de elemento da agregação que sofrerá a operação. Por convenção, este método é nomeado Visit. No diagrama, este é o papel da classe TWOperacoesPA.

A implementação das operações em si é feita em classes chamadas Concrete Visitor. Essas classes são heranças simples do Visitor, o que significa que elas terão que fornecer sua própria versão de cada método Visit definido na classe base. Com isso, a operação tratará de forma condizente os diferentes componentes da coleção. No exemplo, as classes TWRecursoImprimir e TWRecursoSaveToXml fazem esse papel.

Chamamos de Visitable (ou Element) a classe que define um método Accept capaz de receber uma instância da classe de operação e executar a versão correta do método Visit dessa operação. Ela, portanto, serve de ponto de entrada da execução, definindo o comportamento esperado para todas as heranças que poderão ser "visitadas". São às vezes chamadas de Element por coincidir com a classe base dos elementos que compõem uma agregação. A classe que exerce esse papel no diagrama de exemplo é a TWRecursoProducao.

Os Concrete Visitable (ou Concrete Element) são as classes que efetivamente implementam o método Accept, direcionando a execução da operação para o tipo de objeto que representam. Isto é, chamando o método Visit correto da operação passada como parâmetro. As classes TWMateriaPrima, TWMaquina e TWRoteiro são exemplos disso no diagrama.

O Object Structure é a classe que contém a coleção de elementos sobre os quais uma operação será executada. Ela, então, terá que prover um meio para que a coleção seja percorrida de modo que todos os seus componentes possam ser submetidos à operação desejada. Este é o papel da classe TWProdutoAcabado no diagrama.

O Client é responsável por manter a instância tanto do Object Structure quanto da operação que será executada. Ela também navega os elementos da estrutura, executando em cada um a operação solicitada.

O padrão Iterator também é projetado para permitir a navegação entre elementos que compõem um objeto. A diferença é que no Iterator os elementos devem ser herança de uma mesma classe enquanto no Visitor isso não é obrigatório.

O cenário onde o padrão Visitor é aplicável se assemelha ao uso de interfaces, já que em ambos os casos, uma estrutura externa estabelece as operações que a classe é capaz de executar. No entanto, interfaces forçam a implementação das operações dentro da classe ao invés de fazê-lo em classes separadas, como no Visitor. Obviamente, ambos os recursos podem ser utilizados em conjunto para produzir uma solução mais flexível.

Alguns críticos alegam que o Visitor fere o encapsulamento das classes ao obrigar que parte de seu funcionamento seja delegada a outra classe. Mas, podemos encarar essa classe extra como uma operação distinta, minimizando ou até mesmo eliminando o efeito da quebra de encapsulamento.

No próximo post eu mostro uma sugestão de implementação desse pattern usando o Delphi.

Mais Informações
Posts sobre Design Patterns

Aplicando recursos de localização em Asp.Net

2012-02-14T11:57:00.001-02:00

por Tiago Oliveira*

Embora seja referenciado por uma palavra um tanto quanto estigmatizada - globalização - o fato é que o mundo ficou mesmo menor e os fabricantes de aplicações também passaram a levar isso em consideração. Ao planejar a construção de programas e sites, eles têm agora que incluir o conceito de localização na arquitetura, de uma forma que a aplicação se adeque à linguagem preferida pelo usuário sem que seja necessária uma reengenharia nas linhas de código.

O ASP.NET possui recursos de localização para que possamos fazer aplicações globalizadas, ou seja, para que a aplicação se adeque à região onde ela está sendo executada. A configuração utilizada pelo ASP.NET é a informada no navegador (no caso do IE, está no seguinte caminho : Opções de Internet/Geral/Idiomas), sendo considerado tanto o Idioma quanto a Região estipulados. Segue abaixo um exemplo de configuração:

en-US – Inglês região dos EUA.

pt-BR – Português região do Brasil.

As duas primeiras letras no código representam o Idioma e as duas últimas a região.

Agora vamos aplicar os recursos de localização disponíveis no ASP.NET para modificar esse comportamento padrão e fornecer um mecanismo para que o usuário opte pelo idioma de sua preferência na própria aplicação. Adicione um WebForm contendo 2 botões que, no caso, irão representar os possíveis idiomas suportados para visualização da aplicação : português e inglês.

Adicione um outro WebForm contendo alguns componentes Label, TextBox, etc. Para aplicar a localização às páginas da aplicação, o ASP.NET utiliza arquivos de Resources; por isso, vamos adicionar um arquivo de resource em nossa aplicação: clique no WebForm e selecione na guia Tools do Visual Studio a opção “Generate Local Resource”. Ao escolher essa opção. um arquivo de extensão .RESX com o mesmo nome da página será gerado dentro de uma pasta chamada App_LocalResources que será automaticamente adicionada ao seu projeto.

Dentro desse arquivo .RESX existe a relação de todos os componentes que comportam o recurso de localização, juntamente com a descrição dos campos. No nosso exemplo, esse arquivo irá representar a versão em português da aplicação; para gerarmos o arquivo contendo a versão em inglês, faça uma cópia do arquivo NomeDaSuaPagina.aspx.resx gerado pelo Visual Studio e altere o nome para NomeDaSuaPagina.aspx.en-US.resx. Nesse novo arquivo, faça a tradução dos campos para o Inglês.

No WebForm onde colocamos os 2 botões para identificar os idiomas, iremos passar a localização através de Query String, conforme código abaixo associado ao clique de cada um dos botões:

protected void ImageButton1_Click(object sender, ImageClickEventArgs 
e)

{

Response.Redirect("Conteudo.aspx?Language=pt-BR");

}

protected void ImageButton2_Click(object sender, ImageClickEventArgs 
e)

{

Response.Redirect("Conteudo.aspx?Language=en-US");

}

Na página Conteudo.aspx (representando a página principal da aplicação), precisamos inicializar a cultura de exibição para considerar a que passamos por parâmetro e não aquela que está configurada no navegador. Para isso precisamos sobrescrever o método InitializeCulture da página e ajustar a variável interna UICulture, que é a responsável por controlar o idioma em que a aplicação está sendo exibida:

protected override void InitializeCulture()

{

UICulture = Request.QueryString["Language"]; 

base.InitializeCulture();

}

Ao exibir os textos da página, o ASP.Net passará a considerar automaticamente o conteúdo do arquivo .RESX referente ao idioma e região escolhidos.

* Tiago Oliveira é desenvolvedor na ABC71, onde trabalha com os módulos fiscais, de faturamento e de vendas.

Mais Informações
Software localization, InitializeCulture, Query String

Microsoft abre extensão do C++ para uso em outros compiladores

2012-02-10T15:09:00.001-02:00

Já há algum tempo que os computadores vêm sendo montados com placas gráficas - as chamadas GPUs - cada vez mais poderosas. No início, elas eram requisitadas apenas por quem apreciava jogos no PC pois esse tipo de software exige cálculos complexos intensos para apresentar a parte gráfica, o que usa massivamente as GPUs. Essa história começou a mudar com o Windows Vista, quando o próprio sistema operacional passou a fazer uso mais intenso da capacidade dessas placas, oferecendo aos usuários uma experiência visualmente mais agradável no uso do computador. Com isso, a preocupação de melhorar a apresentação dos programas aproveitando a GPU entrou na lista das empresas desenvolvedoras de software.

Já que se trata de uma CPU extra no computador, muitas vezes a GPU ainda acaba sendo sub utilizada. Mas, acessar plenamente os recursos das GPUs não é uma tarefa trivial. Atenta a isso, a Microsoft vem trabalhando em uma biblioteca para facilitar a utilização desses recursos por qualquer desenvolvedor.

Na verdade, a solução proposta pela Microsoft é estender a linguagem C++, introduzindo nela uma forma nativa e transparente de se ter acesso aos recursos da GPU, fornecendo junto os mecanismos de controle inerentes à computação paralela - notadamente, a sincronização de processamentos.

Abaixo segue uma tradução da reportagem publicada pela Infoworld dando mais detalhes dos planos da Microsoft. A reportagem original em inglês pode ser acessada no link Microsoft opens C++ extension for other compilers.

A Microsoft abriu sua especificação do C++ AMP de modo que ela agora pode ser usada por compiladores de outros fabricantes para aproveitar o poder das GPUs (graphics processing units).

"Estamos vendo cada vez mais gente procurando tirar proveito das GPUs em suas aplicações", disse Tony Goodhew, gerente de produto na Microsoft para o Visual Studio.

A proposta do C++ Accelerated Massive Parallelism (C++ AMP), primeiro desenvolvido para o Visual Studio 11 e liberado junto com a versão preliminar desse software para desenvolvedores em setembro, é permitir que os programadores C++ possam escrever programas que executem em paralelo em ambientes computacionais heterogênios.

Agora, ele é livre para ser utilizado por outros fabricantes de compiladores C++, como a Embarcadero, Intel, e a Free Software Foundation.

Cada vez mais, os fabricantes de GPU, tais como a Nvidia, vêm oferecendo suas GPUs para incrementar a performance de programas, auxiliando a CPU a concluir tarefas que demandam muitos cálculos. Tradicionalmente, programar para computação paralela tem sido uma tarefa complicada, apenas dominada por codificadores altamente especializados que normalmente trabalharam com super computadores em laboratórios ou empresas do mercado financeiro.

Com o C++ AMP, "Não precisarei ser um especialista altamente treinado para alcançar esse hardware," diz Goodhew.

Os engenheiros da Microsoft trabalharam para minimizar a quantidade de mudanças em relação à versão canônica do C++. O C++ AMP realmente traz algumas restrições adicionais necessárias quando se executa um código através de múltiplos processadores. Ele também tem recursos adicionais, como tipos array multidimensionais, bem como suporte para transferência assíncrona em memória, memória compartilhada e sincronização.

Em sua implementação, a Microsoft usou a biblioteca DirectCompute para DirectX do Windows para interagir com as GPUs, embora os fabricantes de compiladores possam se valer de outras interfaces para GPU, como a Cuda da Nvidia. Segundo Goodhew, embora esta versão do AMP tenha sido projetada especificamente para GPUs, ela também assenta as bases para eventualmente suportar outros tipos de aceleradores de hardware.

A especificação está publicada sob a licença Microsoft Community Promise.

A Microsoft lançou o C++ AMP em setembro passado, como parte da versão prévia para desenvolvedores do Visual Studio 11, depois de ter anunciado em junho a intenção de abrir a especificação para o mercado. A próxima release do Visual Studio 11 Beta incluirá suporte adicional para a especificação, que foi apresentada pela empresa sexta-feira na conferência GoingNative 2012 C++, ocorrida semana passada em Redmond, Washington.

A companhia está trabalhando com o comitê de padronização do C++ na esperança de que o grupo usará as ideias do C++ AMP como parte do núcleo da especificação da linguagem C++. Levará um tempo até que isso ocorra, entretanto, dado o longo intervalo entre as atualizações no padrão. A versão mais recente do padrão para o C++, informalmente chamada de C++2011, foi lançada no ano passado, no que foi a primeira grande mudança em quatro anos.

O documento com a especificação do C++ AMP está disponível no formato PDF neste link.

Mais Informações
Microsoft opens C++ extension for other compilers, Especificação do C++ AMP

Informações sobre rotas com a versão 3 da API do Google Maps

2012-01-31T16:46:00.000-02:00

No ano passado eu publiquei dois posts mostrando como traçar rotas usando a versão 3 da API do Google Maps. O primeiro tratava de um cenário básico onde consideramos um endereço de origem e outro de destino; o segundo avançava um passo ao permitir a inclusão de um ou mais pontos intermediários ao trajeto. Por razões distintas, várias pessoas me perguntaram como é possível obter a distância total entre a origem e o destino em uma rota, independendo se vamos efetivamente exibir a rota traçada.

Pra refrescar a memória, o quadro a seguir ilustra os comandos e estruturas básicos necessários pra trabalharmos com uma rota.

var directionsService, directionsRenderer;

var enderDe, enderAte;

directionsService = new google.maps.DirectionsService();

directionsRenderer = new google.maps.DirectionsRenderer();

directionsRenderer.setMap(map);

enderDe = 'ALAMEDA SANTOS, 1000, SÃO PAULO - SP, 01418-9028';

enderAte =

 'AVENIDA NAÇÕES UNIDAS, 17-17, BAURU - SP, 17013-035';

var request = {

origin:endDe, 

destination:endPara,

travelMode: google.maps.DirectionsTravelMode.DRIVING

};

directionsService.route(request, function(response, status) {

if (status == google.maps.DirectionsStatus.OK) {

directionsRenderer.setDirections(response);

}

});)

A linha directionsRenderer.setDirections (response) usa o objeto response para traçar automaticamente a rota no mapa. Esse objeto é do tipo DirectionsResult e é montado pela função route antes de ser repassado como response à nossa função de callback. No entanto, você pode usar manualmente as informações contidas em response sem que a rota precise ser exibida.

De acordo com a documentação, o DirectionsResult possui como única propriedade um Array chamado routes contendo a lista de rotas encontradas pelo serviço para atender a requisição feita. Cada elemento dessa lista traz detalhes de uma rota específica, descrita na forma de um objeto DirectionsRoute, o que inclui detalhes de cada trecho do trajeto, como a distância de cada um (em metros) e o tempo estimado usando o tipo de locomoção escolhido.

Com isso, podemos facilmente obter a distância a ser percorrida para chegar ao destino usando a rota em questão:

directionsService.route(request, function(response, status) {

if (status == google.maps.DirectionsStatus.OK) {

var distancia;

var rota = response.routes[0]; /* Primeira rota */

var etapa = rota.legs[0]; /* única etapa dessa rota */

distancia = etapa.distance.value;

alert ('Distância Total => ' + distancia.toString() + ' metros.');

}

});)

A propriedade legs destrincha cada etapa do trajeto usando objetos do tipo DirectionsLeg para descrevê-las. Por etapa entende-se o deslocamento necessário entre dois endereços. Assim, se você estipulou apenas a origem e o destino, haverá uma única etapa e, por conseguinte, uma única posição em legs. Por outro lado, se você adicionou pontos de referência usando o waypoints na requisição (veja esse post para mais detalhes), haverá uma nova etapa descrevendo como chegar a cada ponto. Nesse caso, será preciso percorrer todas as posições, somando a distância de cada etapa para se obter a distância total da rota:

directionsService.route(request, function(response, status) {

if (status == google.maps.DirectionsStatus.OK) {

var distancia = 0;

var rota = response.routes[0]; /* Primeira rota */

var etapa, i;

for (i = 0; i < rota.legs.length; i++)

{

/* Obtem cada etapa */

etapa = rota.legs[i];

distancia += etapa.distance.value;

}

alert ('Distância Total => ' + distancia.toString() + ' metros.');

}

});)

O detalhamento do caminho a ser seguido dentro de cada etapa do trajeto pode ser acessado através da propriedade steps. Cada passo também possui sua distância mas a soma delas já está consolidada na própria etapa (leg). Tenha em mente que, para certos trajetos, pode acontecer de as informações de distância e duração não estarem disponíveis. Por questão de simplicidade, os scripts acima não levam isso em conta. Um exemplo completo dos recursos mostrados até agora pode ser visto na página abaixo, cujo código fonte está neste link:

Um outro ponto importante a ser lembrado é que a função route é assíncrona. Isto significa que a função de callback que passamos a ela poderá ser executada depois da linha de código imediatamente seguinte ao route. Assim, se tiver que comparar as distâncias de várias rotas, terá que montar uma forma de sincronizar os cálculos para que a comparação só ocorra depois da execução de todos os callbacks envolvidos. Esse efeito normalmente é conseguido através da função javascript setinterval, verificando a cada segundo, por exemplo, se as rotas já estão prontas.

Mais Informações
Traçando rotas com a versão 3 da API do Google Maps - Parte I e Parte II, Google Maps JavaScript API V3

Trabalhando com Ações em Delphi e C++ Builder

2012-01-23T15:32:00.001-02:00

As operações que um usuário pode executar em programas com interface visual podem estar disponíveis de diversas maneiras. As formas mais óbvias e mais utilizadas são os menus, barras de ferramentas, menus de contexto, botões espalhados pela interface e, mais recentemente, os ribbons introduzidos pela interface do Microsoft Office. Com essa variedade de formas de se acessar uma operação, é bastante comum que esse acesso esteja disponível em mais de um lugar.

Do ponto de vista do programador surge então uma questão: qual a melhor maneira de se gerenciar as operações em uma aplicação, notadamente aquelas que estarão acessíveis por mais de uma via ? A solução para quem desenvolve com Delphi ou C++ Builder é um componente que já existe há um bom tempo nesses ambientes, chamado TActionManager.

Como diz o nome, o objetivo do TActionManager é gerenciar as operações que estarão disponíveis para o usuário em uma aplicação, centralizando a configuração básica de cada operação. O componente permite organizar as operações por afinidade (relativas a arquivo, edição, visualizar ou ajuda, por exemplo); informar textos e imagens descritivos da operação a fim de manter a uniformidade visual independente da forma de acesso escolhida; sinalizar se a operação está ativa ou mesmo visível.

E como é que isso tudo se conecta ? Alimentar o TActionManager com operações faz com que o IDE crie instâncias de um outro objeto, o TAction. Cada TAction corresponde a uma operação - ou ação - isolada, independente da interação necessária para ativá-la. Essa ação pode então ser associada à propriedade Action existente em diversos componentes - itens de menu, botões, itens em barras de ferramenta, etc.

Entretanto, certos componentes - como o TActionMainMenuBar e o TRibbon - são configurados diretamente com uma instância do ActionManager e não com ações individuais.

Para dar manutenção nas ações gerenciadas pelo ActionManager, dê um duplo clique nele. Será exibida uma caixa de diálogo como a reproduzida abaixo, onde é possível criar novas ações, excluí-las e rearranjá-las. Selecionar uma ação fará com que o Object Inspector apresente as propriedades relativas a ela.

Há umas poucas propriedades no ActionManager e elas não são obrigatórias; destaco abaixo aquelas que são mais utilizadas:

Images e DisabledImages são TImageList contendo, respectivamente, a imagem que deve ser vinculada a uma ação quando ela está ativa e quando está desabilitada. Em ambos os casos, as imagens devem ser pequenas - 16 x 16 pixels. Uma das propriedades de uma ação é o índice da imagem a ser usada; como só há um índice, a imagem correspondente à ação deve estar exatamente na mesma posição em todas as listas de imagens configuradas.
LargeImages e LargeDisabledImages são os TImageList que contem imagens grandes - 32 por 32 pixels - para as ações configuradas nesse gerenciador. A primeira lista vincula imagens a ações ativas enquanto a segunda traz as imagens grandes para ações desabilitadas. Lembre-se que as imagens relativas a uma ação devem estar na mesma posição, conforme dito no tópico anterior.
State: Permite desativar todas as ações de um única vez, impedindo-as de serem disparadas.
Use a propriedade ActionBars para criar barras de ferramentas associadas ao gerenciador.
FileName indica o caminho completo para um arquivo que armazernará a configuração dinâmica feita pelo usuário final em tempo de execução.

Como se depreende do exposto acima, o gerenciador de ações pode ser usado em conjunto com o TCustomizeDlg para permitir ao usuário final reorganizar as barras de ferramentas.

Uma vez que o gerenciador está preparado, podemos acrescentar-lhe as ações e configurá-las. A lista abaixo mostra as principais propriedades do TAction:

Use Caption para informar o texto padrão para a ação. É esse texto que será usado num item de menu ou como texto de um botão onde a ação for vinculada.
Use Category para organizar as ações, agrupando-as por afinidade, o que facilita a manuntenção de ações tanto para o programador quanto para o usuário final - caso a funcionalidade de configuração seja disponibilizada a ele.
ImageIndex é a posição das imagens a serem usadas para representar a ação em diversos contextos. Cada ação terá à sua disposição o mesmo índice em cada uma das 4 listas existentes no gerenciador de ações.
Uma combinação de teclas pode ser atribuída em Shortcut. Essa combinação é um método alternativo para executar a ação associada a ela.
O evento OnExecute é usado para centralizar a execução da ação. Assim, não é preciso acrescentar código em nenhum outro ponto do programa nem responder a outros eventos; basta configurar a propriedade Action existente no componente que desejar disparar a ação - menus e botões, por exemplo.
Enabled permite habilitar ou desabilitar uma ação individual de forma centralizada. Isto é, altere essa propriedade para que todas as possibilidades de se executar a ação sejam afetadas de uma só vez.
Modifique a propriedade Visible para esconder ou mostrar uma ação de uma só vez em todos os contextos nos quais ela estiver disponível.

Mais Informações
Documentação do TActionManager, Classe TAction

Preparando a execução de um programa em desktop remoto

2011-12-30T10:22:00.001-02:00

A adoção maciça da internet e os benefícios associados a ela têm levado as empresas a optar cada vez com mais frequência por programas que possam ser executados nessa infraestrutura. O principal benefício aqui está relacionado aos custos já que os desktops não precisam ser tão potentes - basta que tenham acesso à internet para executarem esses programas remotos - e a manutenção dos equipamentos passa ser centralizada.

Por outro lado, nem todos os programas em uso pelas empresas operam nativamente na internet. Seja por que são programas legados ou por que o fabricamente ainda não os preparou para o ambiente web ou simplesmente porque há muitos programas e não houve tempo hábil para uma conversão em massa. Por isso, programas como o RDS (Remote Desktop Services) da Microsoft e as soluções da Citrix para virtualização de desktops têm sido bastante adotados.

Essas soluções permitem que um usuário execute remotamente os programas que necessita, através de um desktop virtual acessível via rede local ou internet. Com isso, o hardware mais robusto fica centralizado num servidor e pode ser compartilhado por diversos usuários simultâneos.

Nesse ambiente, diversos usuários podem estar executando sua aplicação no mesmo computador remoto, compartilhando recursos como a pasta de trabalho, memória mapeada, disco, etc. Desse modo, as diferentes execuções simultâneas do programa podem conflitar entre si. Decisões baseadas no nome do computador, seu endereço IP ou outra informação de hardware também podem causar problemas já que todos os usuários remotos lerão os mesmos valores. A ABC71, por exemplo, usa o nome do computador onde nosso ERP está em execução como parte do controle de licenças.

Em Windows, normalmente as soluções de desktop virtual se baseiam nos serviços de Remote Desktop (antes chamado de Terminal Services), razão pela qual podemos usar a Remote Desktop Services API para preparar nossas aplicações para que rodem nesse ambiente. Essa API permite resgatar e modificar informações sobre um usuário específico, além de executar tarefas relativas à administração do serviço.

Para começar, temos que determinar se o programa está executando num desktop convencional ou num virtual. Isso pode ser conseguido com uma chamada à função GetSystemMetrics. Saber que estou numa sessão remota me permite, por exemplo, ajustar uma pasta de trabalho coerente para cada execução distinta do meu programa.

function TForm1.IsRemoteSession : boolean;

var res : integer;

begin

  res := GetSystemMetrics (SM_REMOTESESSION);

  Result := (res <> 0);

end;

A função GetSystemMetrics é um curinga da API do Windows; com ela é possível recuperar uma porção de parâmetros do ambiente operacional. Chamada com SM_REMOTESESSION, ela retorna um valor diferente de zero se o programa estiver num desktop virtual.

Muitas informações valiosas sobre a sessão remota em andamento podem ser obtidas através da função WTSQuerySessionInformation. No exemplo abaixo, eu a utilizo para recuperar o nome do computador que está acessando o desktop remoto:

procedure TForm1.GetSessionInfo;

var lSessionId: DWORD;

    lBuffer : PChar;

    lBytesReturned : DWORD;

    lStationName : String;

begin

  lSessionId := 0;

  { Descobre a identificação da sessão do usuário com base na identificação do programa no Windows }

  if not ProcessIdToSessionId (GetCurrentProcessId (), DWORD(@lSessionId)) then

    raise Exception.Create ('Não foi possível obter Remote SessoinId');

  lBuffer := Nil;

  lBytesReturned := 0;

  lStationName := '';

  { Obtem nome da máquina Client }

  if (WTSQuerySessionInformation (WTS_CURRENT_SERVER_HANDLE,

                                   lSessionId,

                                   WTSClientName,

                                   lBuffer,

                                   lBytesReturned))

  then

    lStationName := String(lBuffer)

  else

    raise Exception.Create ('Não foi possível obter o nome da estação');

  { Libera a memória alocada automaticamente }

  WTSFreeMemory (lBuffer);

  { ... }

end;

Vamos por partes. Para recuperar as informações de uma sessão remota, primeiro temos que identificar essa sessão. A função ProcessIdToSessionId da API do Windows nos fornece isso, mapeando o Process ID de nosso programa para a correspondente identificação da sessão remota onde ele está executando.

O passo seguinte é chamar a função WTSQuerySessionInformation para levantar as informações desejadas. Essa função recebe 5 parâmetros. O primeiro é um handle para o servidor da sessão remota. No exemplo, passei a constante WTS_CURRENT_SERVER_HANDLE para indicar que quero informações sobre o servidor atual. Poderia ter usado WTSOpenServer para abrir outro servidor remoto.

O segundo parâmetro é a identificação da sessão que obtivemos no primeiro passo. O parâmetro seguinte é o que determina qual informação será recuperada. Os valores permitidos são os listados no enumerado WTS_INFO_CLASS. No exemplo, usei WTSClientName para obter o nome do computador do usuário que diparou o acesso remoto; a lista de informações recuperáveis inclui o endereço IP desse mesmo computador, a pasta de trabalho remota (no servidor), o nome do usuário e informações sobre o uso da sessão e sobre a Client, dentre outras.

Os dois últimos parâmetros são, respectivamente, um ponteiro para a área que receberá a informação solicitada e a quantidade de bytes que essa informação está ocupando. Como ambos são calculados pela função WTSQuerySessionInformation, não é preciso alocar previamente a memória para eles. No entanto, é nossa responsabilidade liberar a memória alocada usando a função WTSFreeMemory, como mostra o passo final do código do exemplo.

Se tivesse usado GetComputerName, eu obteria o nome do computador remoto, isto é, o servidor onde o programa está efetivamente sendo executado. A questão é que o mesmo nome seria retornado para qualquer usuário que acesse um desktop remoto nesse servidor ...

A lista de funções da Remote Desktop Services API inclui ainda formas de administrar o RDS tais como iniciar e encerrar sessões, inventariar as sessões ativas, modificar configurações de uma sessão, etc.

Mais Informações
Remote Desktop Services API Functions, Função GetSystemMetrics, Função ProcessIdToSessionId, Função WTSFreeMemory