Webservices

Nunca me preocupei muito com WebServices, mas devido a uma necessidade no meu trabalho tive que aprender, então resolvi  escrever uma alguma coisa relacionada baseado no textos e exemplos que encontrei na internet, não sei ainda quantos artigos vou escrever mas nesse primeiro vou dar uma rápida pincelada no o que é um WebService, pretendo ainda postar em um próximo artigo um exemplo prático de utilização de WebServices com o Delphi e se houver inspiração suficiente mais um artigo demonstrando a criação de WebServices.
WebServices são tidos como uma importante evolução na construção de aplicações distribuídas, mas afinal o que é um WebService?
Muito se discute sobre a exata definição de WebService, de qualquer maneira, no mínimo um WebService é um software disponibilizado  via internet e que usa como sistema de mensagens um XML padronizado. Esse XML é usado para codificar toda a comunicação com o WebService. Por exemplo o cliente envia um XML para o WebService e recebe como resposta outro XML. Como toda a comunicação é feita via XML um webservice não está atrelado a nenhuma linguagem de programação ou sistema operacional, o que significa que um WebService feito em Java e compilado em Linux pode ser acessado facilmente por uma aplicalção Delphi no Windows.
Além dessa definição um WebService tem duas propriedades desejáveis:

1.    Um WebService pode ter um interface pública, definida em XML. Essa interface descreve todos os métodos disponíveis e suas respectivas assinaturas. Atualmente a definição dessa interface é feita através do WSDL (Web Service Description Language), ou linguagem de descrição de webservices.

2.    Se você criou um WebService deve haver algum mecanismo para que você torne este WebService público. Da mesma maneira deve haver algum modo de se localizar um WebService quando há a necessidade. Isso atualmente é feito através do UDDI (Universal Description, Discovery, and Integration).

Então, simplificando a diferença entre os Webservices e s chamadas RPC que eram usadas anteriormente para aplicações distribuídas é o XML. O XML é o coração dos WebServices, antes dele era possível a integração entre aplicações, porém a sua utilização padronizada facilitou em muito essa integração.

Atualmente há webservices para quase todo tipo de tarefa, desde pesquisa de clima, consulta de tempo, validação de cartão de crédito, etc.. Para uma rápida consulta a alguns web services existentes acesse http://www.xmethods.net/.
A pilha de protocolos para um WebService funciona da seguinte maneira:

1.    Transporte. Esta camada é responsável por levar a comunicação do cliente ao WebService e vice-versa, e usa mais comumente os seguintes protocolos: HTTP, FTP,e SMTP.
2.    Mensagem XML. Esta camada é responsável por codificar a comunicação de modo que ela possa ser compreendida pelas duas pontas. E atualmente os padrões utilizados são o XML-RPC e o SOAP.
3.    Descrição. Esta camada descreve a interface pública de um WebService e utiliza WSDL.
4.    Serviço de Descoberta. Responsável por centralizar o registro,  publicação e busca de WebServices, é atualmente feita via UDDI.

Felizmente não é necessário saber esses protocolos todos ( e nem todos os outros que podem ser utilizados, como WSFL, SOAP-DSIG, USML, e outros, ufa que sopa de letrinhas rsrs… ). Levando em conta que você já sabe o básico do HTTP aprender XML é a melhor maneira de começar.
Atualmente dois padrões são os mais utilizados para a comunicação de WebServices:

1.    XML-RPC é um protocolo que utiliza XML para efetuar chamadas remotas (RPC), as solicitações são codificadas em XML e envida via HTTP POST, e o XML de resposta e embutido no corpo da mensagem HTTP. Segue um exemplo das mensagens XML-RPC para um serviço de previsão do tempo.

Requisição:

<?xml version="1.0" encoding="ISO-8859-1"?>
<methodCall>
   <methodName>weather.getWeather</methodName>
<params>
<param><value>10016</value></param>
   </params>
</methodCall>

Resposta:

<?xml version="1.0" encoding="ISO-8859-1"?>
<methodResponse>
<params>
<param>
         <value><int>65</int></value>
      </param>
   </params>
</methodResponse>

2.    SOAP assim como o XML-RPC é independente de plataforma, e embora possa ser utilizados em vários sitemas de mensagem é mais comumente utilizado para chamadas remotas (RPC) sobre HTTP. Segue um exemplo das mensagens XML-RPC para um serviço de previsão do tempo.

Requisicao:

<?xml version='1.0' encoding='UTF-8'?>
<SOAP-ENV:Envelope
   xmlns:SOAP-ENV="http://www.w3.org/2001/09/soap-envelope"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <SOAP-ENV:Body>
      <ns1:getWeather
         xmlns:ns1="urn:examples:weatherservice"
         SOAP-ENV:encodingStyle=" http://www.w3.org/2001/09/soap-encoding
         <zipcode xsi:type="xsd:string">10016</zipcode>
      </ns1:getWeather>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Resposta:

<?xml version='1.0' encoding='UTF-8'?>
<SOAP-ENV:Envelopexmlns:SOAP-ENV="http://www.w3.org/2001/09/soap-envelope"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <SOAP-ENV:Body>
      <ns1:getWeatherResponse
         xmlns:ns1="urn:examples:weatherservice"
         SOAP-ENV:encodingStyle="http://www.w3.org/2001/09/soap-encoding">
         <return xsi:type="xsd:int">65</return>
      </ns1:getWeatherResponse>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Note que o a construção do XML para o SOAP é mais complexa que para o XML-RPC e utiliza namespaces e XML Schemas.

Segue abaixo um exemplo da utilização do WSDL para a descrição de um serviço, vale lembra que uma interface pública pode conter o seguinte:

1.    Informação sobre todas as funções disponíveis publicamente;

2.    Informação sobre o tipo de Dados para todas as mensagens XML;

3.    Informação sobre o protocolo de transporte a ser utilizado;

4.    E, Informação sobre a localização do serviço.

Note ainda no XML duas coisas, o elemento <message>  que define as mensagens relativas ao serviço, neste caso “getWeatherRequest” e “getWeatherResponse”, e também o elemento <service> que especifica que o serviço e está disponível através de SOAP e sua localização.

WSDL:

<?xml version="1.0" encoding="UTF-8"?>
<definitions name="WeatherService"
   targetNamespace="http://www.site_com_o_servico.com/wsdl/WeatherService.wsdl"
   xmlns="http://schemas.xmlsoap.org/wsdl/"
   xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
   xmlns:tns="http://www.site_com_o_servico.com/wsdl/WeatherService.wsdl"
   xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <message name="getWeatherRequest">
<part name="zipcode" type="xsd:string"/>
   </message>
   <message name="getWeatherResponse">
<part name="temperature" type="xsd:int"/>
   </message>
<portType name="Weather_PortType">
      <operation name="getWeather">
         <input message="tns:getWeatherRequest"/>
         <output message="tns:getWeatherResponse"/>
      </operation>
   </portType>

   <binding name="Weather_Binding" type="tns:Weather_PortType">
      <soap:binding style="rpc"
         transport="http://schemas.xmlsoap.org/soap/http"/>
      <operation name="getWeather">
         <soap:operation soapAction=""/>
         <input>
            <soap:body
               encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
               namespace="urn:examples:weatherservice"
               use="encoded"/>
         </input>
         <output>
            <soap:body
               encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"
               namespace="urn:examples:weatherservice"
               use="encoded"/>
         </output>
      </operation>
   </binding>

   <service name="Weather_Service">
      <documentation>WSDL File for Weather Service</documentation>
<port binding="tns:Weather_Binding" name="Weather_Port">
         <soap:address
            location="http://localhost:8080/soap/servlet/rpcrouter"/>
      </port>
   </service>
</definitions>

Segue abaixo uma pequena lista dos atalhos na IDE do Delphi em sua configuração default e a versão em que foi disponibilizado, lembro que não é a lista completa e que ainda há outros que não foram citados aqui, mais acho que já da para quebrar um galho, rsrsr…

Há determinas situações em que se torna necessário saber o caminho de um diretório de sistema, porém sabemos que esse diretório pode variar de acordo com a versão do windows, ou mesmo com o modo com que foi instalado, por exemplo o diretório do windows normalmente é “C:\WINDOWS”, porém em máquinas com o Windows NT ele é por padrão “C:\WINNT”, e ainda há a posibilidade de se customizar o diretório durante  instalação, nas linhas abaixo eu mostro como identificar o diretórios do windows para qualquer instalação, e também como descobrir alguns outros diretórios que podem ser interessantes, assim como a pasta “Meus Documentos”.

Há mais de uma maneira para descobrir o path de alguns diretório e primeiro vou mostrar algumas funções de uso específico e mais adiante mostrarei uma função que pode recuperar um grande gama de diretórios de sistema, em ambos os casos as funções se encontram na unit “shlobj” e utizam a API do windows:

1. Funções de uso específico

//Diretório Temporário do usuário( {usuario}\Configurações Locais\Temp )
function getTempDir: String;
var lng: DWORD;
begin
 SetLength(Result, MAX_PATH);
 lng := GetTempPath( MAX_PATH, PChar(Result)) ;
 SetLength(Result, lng) ;
end;

//Diretório do Windows(c:\windows)
function getWinDir: String;
var
 lng: DWORD;
begin
 SetLength(Result, MAX_PATH) ;
 lng := GetWindowsDirectory(PChar(Result), MAX_PATH);
 SetLength(Result, lng) ;
end;

//Diretório de sistema(c:\windows\system32)
function getSysDir: String;
var
 lng: DWORD;
begin
 SetLength(Result, MAX_PATH) ;
 lng := GetSystemDirectory(PChar(Result), MAX_PATH);
 SetLength(Result, lng) ;
end;

2. Função de uso geral

Para esta função é necessário utilizar de constantes que estão declaradas na unit “shlobj”:

function getSpecialDir: string;
 var
 r: Bool;
 path: array[0..MAX_PATH] of Char;
 begin
 //substitua COLOQUE_AQUI_A_CONSTANTE_DESEJADA
 //pela constante relativa ao diretório desejado
 r := ShGetSpecialFolderPath(0, path, COLOQUE_AQUI_A_CONSTANTE_DESEJADA, False);
 if not r then raise Exception.Create('Diretório não Encontrado');
 Result := Path;
 end;

Vale notar que nem todas as possibilidades são contempladas, para algumas você terá que consultar a documentação do windows, nas versões mais antigas do delphi ele pode ser encontrado na pasta documentação e nas mais recentes ele vem junto do help, procure por “CSIDL”, no entanto para facilata a sua vida eu já coloque aqui as mais usadas, basta que declare as constantes da seguinte maneira:

const
 CSIDL_ADMINTOOLS =$0030;
 CSIDL_COMMON_ADMINTOOLS =$002f;
 CSIDL_COMMON_DESKTOPDIRECTORY =$0019;
 CSIDL_COMMON_DOCUMENTS =$002e;
 CSIDL_COMMON_FAVORITES =$001f;
 CSIDL_MYDOCUMENTS =$000c;
 CSIDL_MYMUSIC =$000d;
 CSIDL_MYPICTURES =$0027;
 CSIDL_MYVIDEO =$000e;
 CSIDL_PROGRAM_FILES =$0026;
 CSIDL_PROGRAM_FILES_COMMON =$002b;
 CSIDL_SYSTEM =$0025;
 CSIDL_WINDOWS =$0024;

Segue ainda abaixo uma lista das principais constantes declaradas e não declaradas na unit “shlobj”:
Algumas das Constantes Definidas na unit SHLOBJ:
CSIDL_DESKTOP                         = $0000;   –{USUARIO}\Desktop
CSIDL_PROGRAMS                      = $0002;   –{USUARIO}\Menu Iniciar\Programas
CSIDL_PERSONAL                       = $0005;   –{USUARIO}\Meus Documentos
CSIDL_FAVORITES                      = $0006;   –{USUARIO}\Favoritos
CSIDL_STARTUP                         = $0007;   –{USUARIO}\Menu Iniciar\Programas\Inicializar
CSIDL_SENDTO                          = $0009;   –{USUARIO}\SendTo
CSIDL_STARTMENU                    = $000b;   –{USUARIO}\Menu Iniciar
CSIDL_DESKTOPDIRECTORY       = $0010;   –{USUARIO}\Desktop
CSIDL_FONTS                             = $0014;   –C:\Windows\Fonts
CSIDL_COMMON_STARTMENU   = $0016;   –{All Users}\Menu Iniciar
CSIDL_COMMON_PROGRAMS     = $0017;   –{All Users}\Menu Iniciar\Programas
CSIDL_COMMON_STARTUP        = $0018;   –{All Users}\Menu Iniciar\Programas\Inicializar
CSIDL_COMMON_DESKTOPDIRECTORY       = $0019;   –{All Users}\Desktop
CSIDL_APPDATA                        = $001a;   –{USUARIO}\Dados de Aplicativos
CSIDL_LOCAL_APPDATA            = $001c;   –{USUARIO}\Configurações Locais\Dados de Aplicativos
CSIDL_COMMON_FAVORITES     = $001f;   –{All Users}\Favoritos
CSIDL_INTERNET_CACHE           = $0020;   –{USUARIO}\Configurações locais\Temporary Internet Files
CSIDL_COOKIES                          = $0021;   –{USUARIO}\Cookies
CSIDL_HISTORY                          = $0022;   –{USUARIO}\Configurações locais\Histórico
CSIDL_PROFILE                           = $0028;   –{USUARIO}
CSIDL_COMMON_MUSIC             = $0035;   –{All Users}\Minhas Músicas
CSIDL_COMMON_PICTURES        = $0036;   –{All Users}\Minhas Imagens
CSIDL_COMMON_VIDEO             = $0037;   –{All Users}\Meus Vídeos

Algumas Constantes Não Definidas:
CSIDL_ADMINTOOLS                    = $0030    –{USUARIO}\Menu iniciar\Programas\Ferramentas administrativas
CSIDL_COMMON_ADMINTOOLS   = $002f    –{All Users}\Menu iniciar\Programas\Ferramentas administrativas
CSIDL_COMMON_DOCUMENTS    = $002e    –{All Users}\Documentos
CSIDL_MYMUSIC                           = $000d    –{USUARIO}\Minhas Músicas
CSIDL_MYPICTURES                      = $0027    –{USUARIO}\Minhas Imagens
CSIDL_MYVIDEO                           = $000e    –{USUARIO}\Meus Vídeos
CSIDL_PROGRAM_FILES                = $0026    –C:\Arquivos de Programas
CSIDL_PROGRAM_FILES_COMMON  = $002b    –C:\Arquivos de Programas\Arquivos Comuns
CSIDL_SYSTEM                             = $0025    –C:\Windows\System32
CSIDL_WINDOWS                         = $0024    –C:\Windows

Para fazer o teste eu montei uma tela básica com 2 TComboBox( cbxIdiomaOrigem, cbxIdiomaDestino), 2 TMemo( mmoOerigem, mmoDestino), e um botão.

Não se esqueça de declarar as seguintes units IdHTTP, HTTPApp, StrUtils;

Ao clicar no botão traduzir o seguinte código será executado

//Associar evento ao ao botão
procedure TForm1.TraduzirClick(Sender: TObject);
 //função para traduzir
 function translate(ss,lng1, lng2:string):string;
 var s:widestring;
 a,b:integer;
 http:TIdHTTP;
 begin
 //cria um componente TIdHttp(usando o Indy)
 http:= TIdHTTP.Create;
 try
 //Efetua um get passando como parametros
 //o texto e o par de idiomas
 s:=http.Get('http://translate.google.com/translate_t?text='
 +httpencode(ss)+'&sl='+lng1+'&tl='+lng2);
 //pega o texto traduzido na resposta "s"(html com a resposta)
 a:=posex('>',s,pos('id=result_box',s));
 b:=posex('</div>',s,a);
 //e retorna
 result:=copy(s,a+1,b-a-1);
 finally
 http.Free;
 end;
 end;
var lng1, lng2: String;
begin
 //verifica se os 2 idiomas estão selecionados
 if (cbxIdiomaDestino.ItemIndex =-1) or
 (cbxIdiomaOrigem.ItemIndex = -1) then
 raise Exception.Create('Escolha o Idioma de origem e Destino');

 //pega os idiomas dos Combos
 lng1 := PCHAR(Integer(cbxIdiomaOrigem.Items.Objects[cbxIdiomaOrigem.ItemIndex]));
 lng2 := PCHAR(Integer(cbxIdiomaDestino.Items.Objects[cbxIdiomaDestino.ItemIndex]));

 //chama a tradução
 mmoDestino.Text := translate(mmoOrigem.Text, lng1, lng2);
end;

Para carregar a lista de idiomas declare uma constante

const LANGUAGE : array[ 1..23, 1..2] of String = (('de','Alemão'),
                                                  ('ar','Árabe'),
                                                  ('bg','Búlgaro'),
                                                  ('zh-CN','Chinês'),
                                                  ('ko','Coreano'),
                                                  ('hr','Croata'),
                                                  ('da','Dinamarquês'),
                                                  ('es','Espanhol'),
                                                  ('fi','Finlandês'),
                                                  ('fr','Francês'),
                                                  ('el','Grego'),
                                                  ('hi','Hindi'),
                                                  ('nl','Holandês'),
                                                  ('en','Inglês'),
                                                  ('it','Italiano'),
                                                  ('ja','Japonês'),
                                                  ('no','Norueguês'),
                                                  ('pl','Polonês'),
                                                  ('pt','Português'),
                                                  ('ro','Romeno'),
                                                  ('ru','Russo'),
                                                  ('sv','Sueco'),
                                                  ('cs','Tcheco'));

E no Evento onCreate do Form execute

//associa ao OnCreate do Form
procedure TForm1.FormCreate(Sender: TObject);
var i, j: Integer;
    idioma: PCHAR;
begin
  //preenche os combos com os idiomas
  cbxIdiomaOrigem.Items.Clear;
  for i := Low(LANGUAGE) to High(LANGUAGE) do
  begin
    GetMem(idioma, 1 + Length(LANGUAGE[i,1]));
    StrPCopy(idioma, LANGUAGE[i,1]);
    cbxIdiomaOrigem.Items.AddObject(LANGUAGE[i,2], TObject(Integer(idioma)));
  end;
  cbxIdiomaDestino.Items.Assign(cbxIdiomaOrigem.Items);
end;

Segue abaixo algumas dicas de como incrementar o seu TDbGrid para que sua aplicação tenha uma aparência um pouco mais profissional:

- Colorir condicionalmente as linhas.

Ex.: seu grid mostraria as linha pares de uma cor diferenciada para facilitar a leitura, ou destacaria o conteúdo de um campo de acordo com o valor:

//Atribua a seguite Procedure
//ao evento OnDrawColumnCell
procedure TForm1.DBGrid1DrawColumnCell(
  Sender: TObject; const Rect: TRect;
  DataCol: Integer; Column: TColumn;
  State: TGridDrawState);
var cor_fundo, cor_fonte: TColor;
begin
  with Sender as TDbGrid do
  begin
    //formatação condicional
    if DataSource.DataSet.FieldByName('SIZE').AsInteger > 20 then
      Canvas.Font.Style := Canvas.Font.Style
                           + [fsBold];

    //para todas as linhas pares
    if (DataSource.DataSet.RecNo
        mod 2 = 0) then
    begin
      if gdSelected in State then
      begin
        cor_fundo := $0097FFFF;
        cor_fonte := clInfoText;
      end
      else
      begin
        cor_fundo := clInfoBk;
        cor_fonte := Font.Color;
      end;

      //altere as propriedades do
      //canvas do grid para obter
      //o efeito desejado
      Canvas.Brush.Color := cor_fundo;
      Canvas.Font.Color := cor_fonte;
    end;

    //desenha texto da célula
    DefaultDrawColumnCell( Rect,
                           DataCol,
                           Column,
                           State);
  end;
end;

- Inserir Imagens nas células
Ex.: Exibir uma imagem dependendo do tipo valor de um campo.
adicionar no código anterior:

var [...]
    aux_rect: TRect;
    largura: Integer;
    bmp: TBitMap;
begin
[...]
    aux_rect := Rect;
    bmp := TBitmap.Create;
    try
      //pega a imagem do imagelist
      ImageList1.GetBitmap(0,bmp);
      //pega a largura da imagem
      largura := (Rect.Bottom -
                  Rect.Top);
      aux_rect.Right := Rect.Left +
                        largura;
      //desenha a imagem
      Canvas.StretchDraw(aux_rect,bmp);
    finally
      bmp.Free;
    end;

    //zera a área de desenho
    //e prepara para escrita
    //desconsiderenado a área
    //da imagem
    aux_rect := Rect;
    aux_rect.Left := aux_rect.Left +
                     largura;

    //substituir o contorno
    //anterior pelo novo
    DefaultDrawColumnCell( aux_rect,//Rect,
                           DataCol,
                           Column,
                           State);
[...]
end;

Quando você quer criar um componente sempre fica aquela dúvida, e agora de qual classe o meu componente deve herdar??

Segue abaixo uma pequena ajuda.

1. Se você precisa apenas adicionar uma função ou propriedade a mais em um componente já existente basta herdar do próprio componente.( ex.: TEdit, tForm, TMemo, etc..)
   
2. Quando você precisa não só adicionar bem como remover propriedades e funções de um componente herde da classe “Custom” deste componente, que segundo às práticas de padrões devem ser criadas para todos os componentes possuindo suas propriedade e métodos como “protected“.( ex.: TCustomEdit, TCustomForm, TCustomMemo, etc..)
3. Qualquer componente que precise receber foco precisa de um “window handle”, e este foi introduzido primeiramente na classe TWinControl, portanto utulize a classe TCustomControl que é derivada dela e possuí seu próprio “Canvas“.
4. Se o seu componente vai apenas exibir informações e não necessita receber foco utilize TGraphicControl.( ex.: imagens, label, etc…)
5. E por fim há aqueles componentes que não são exibido em tempom de execução e são utilizados tão somente para nossa conveniência em tempo de design, para estes herde de TComponent.( Ex.: componetes de acesso ao BD, atualização, regra de negócio, etc…)

Se você está desenvolvendo um componente, ou já desenvolveu criou um editor para ele, provavelmente já se deparou com a mensagem “File not found: ‘ToolsAPI.dcu’”.

Esta mensagem ocorre quando você declara a unit ToolsAPI na unit de seu componente e mesmo com todos os “paths” possíveis e imagináveis apontando para ela não há maneira de compilar o projeto.

Esse erro ocorre à partir do Delphi 6 e é causado pelo fato dos desenvolvedores do Delphi estarem tentando separar o conteúdo dos pacotes, mantendo nos pacotes de Tempo de Design somente coisas relacionadas ao tempo de design e pacotes de tempo de execução( runtime) idem.

Para solucuinar esse problema você deve incluir nos “requires” do seu pacote o arquivo “designide.dcp” que pode ser encontrado ou na pasta “delphi\bin” ou na pasta “delphi\lib” dependendo da versão do seu delphi.

O arquivo “designide.dcp” é o arquivo de definições e cabeçalho do Pacote “designide.bpl” que contém diversas funções para auxiliar na integração de componentes com a IDE do Delphi.

Espero que possa ter ajudado.

E Aguardem novas dicas para a criação de componentes.

Segue link referente a notícia

Estou adicionando alguns links que tem sido úteis para mim durante esses anos e espero que possam lhes servir também, esse é um processo contínuo e estarei postando sempre que adicionar algo relevante.

Code Gear Blogs – Precisa comentar????

Delphi About – Site com muito conteúdo para programadores Delphi, tanto iniciantes quanto experientes.

Swiss Delphi Center – Muitas Dicas para Delphi.

Mustang Peak – Ótimos artigos e exemplos, principalmente sobre Open Tools API.

Torry’s – Um dos melhores lugares para achar um componente.

Bom, acho que aqui tenho que falar uma pouco de mim e do que eu espero deste blog rsrsrsr….

Sou formado na FATEC em Processamento de Dados, trabalho com análise de sistemas desde 2001, principalmente com Delphi, e a idéia de criar esse blog é para que eu possa compartilhar meus pensamentos sobre delphi e outras coisa aleatórias que passarem pela minha cabeça, pretendo colocar artigos, componentes, código e falar um pouco das experiências que tenho e tive no meu dia-a-dia nesta área, espero que possa útil para alguém…