Montebugnoli Programação

Windows Forms - Hierarquia de Formulários

2019-11-13T23:07:00.002-03:00

Caro amigo leitor,

É considerada uma boa prática utilizarmos hierarquia de formulários quando o assunto é cadastro. Uma das primeiras tarefas quando desenvolvemos sistemas é de implementar formas para facilitar e agilizar o desenvolvimento de tarefas corriqueiras, economizando tempo, como por exemplo a base de um formulário de cadastro. Implementaremos neste artigo automaticamente todos os principais botões (Ajuda, Novo,Alterar, Excluir, Cancelar, Gravar, Pesquisar, Imprimir e Sair) junto com suas devidas chamadas. Todo este trabalho será desenvolvido através de uma “Class Library”, que na tradução significa “Biblioteca de Classe”, facilitando o uso em futuros projetos. Faremos todo este trabalho com o auxílio da ferramenta Microsoft Visual Studio 2017 Community.

Criando um Novo Projeto

Inicie um novo projeto no MVS2017 clicando em “Arquivo/Novo/Projeto...”. Clique na opção “Aplicativo do Windows Forms (.NET Framework)”, defina um Nome, como por exemplo “WindowsFormsApp” e por final clique no botão “Ok”. Ver Imagem 01.

Figura 01: Novo Projeto.

Dentro deste projeto que herdaremos os formulários desejados.

Criando a Biblioteca de Classes

Para adicionar a “Class Library” clique com o botão direito sobre a solução escolhendo “Adicionar Novo Projeto”

escolhendo a opção “Biblioteca de Classes (.NET Framework)”. Defina um nome para a mesma, no nosso caso deixaremos como “Padrao”.Dentro desta biblioteca armazenaremos o formulário Padrão Base. Ver Figura 02.

Figura 02: Biblioteca de Classes.

A nossa Solução será composta da seguinte estrutura:

1 – Fpadrao (Biblioteca de Classe)

2 – WindowsFormsApp (Aplicativo do Windows Forms)

A Figura 03 nos dá uma noção da estrutura do projeto.

Figura 03: Gerenciador de Soluções.

Criando um novo projeto

O primeiro passo será o de criar o formulário base, para isto clique com o botão direito sobre o “WindowsFormsApp” escolhendo um novo Formulário. Defina um nome para o mesmo, exemplo: “FormularioPadrao”. Adicione no formulário um componente do tipo “ToolStrip” com as propriedades:

Autosize: False
GripStyle: Hidden

Para adicionar os itens de menu deveremos clicar na Propriedade “Items”. Dentro do Editor de Coleção de Itens adicione os botões necessários alterando as seguintes propriedades:

Image: System.Drawing.Bitmap (escolha a imagem do botão)
DisplayStyle: Image
ImageScaling: None
Text: Nome do Botão, por exemplo “Novo”
Autosize: False

Na Imagem 04 teremos a estrutura completa.

Figura 04: Editor de Coleção de Itens.

Note que utilizei alguns “ToolStripSeparator” para separar os botões, proporcionando uma melhor distribuição entre os mesmos.

Teremos um resultado idêntico ao da Figura 05.

Figura 05: Formulário Padrão.

Codificando o Exemplo

O método “public partial class” será do tipo “Form“ e no método Construtor não teremos nada de novidade. Implementaremos neste cadastro base o método “public virtual” do componente “Toolstrip”, permitindo utilizá-lo nos cadastros.

using System.Windows.Forms;

namespace FPadrao

{

public partial class FormularioPadrao : Form

{

public FormularioPadrao()

{

InitializeComponent();

}

Método padrão do Construtor.

public virtual void toolStrip1_ItemClicked(object sender, ToolStripItemClickedEventArgs e)

{

switch (toolStrip1.Items.IndexOf(e.ClickedItem))

{

case 0: //Botão Ajuda

MessageBox.Show("Rotinas referentes ao Arquivo de Ajuda ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 2: //Botão Inclusão

MessageBox.Show("Rotinas referentes à Inclusão ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 3: //Botão Alteração

MessageBox.Show("Rotinas referentes à Alteração ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 4: //Botão Exclusão

MessageBox.Show("Rotinas referentes à Exclusão ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 6: //Botão Cancelar

MessageBox.Show("Rotinas referentes ao Cancelamento ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 7: //Botão Salvar

MessageBox.Show("Rotinas referentes à Gravação ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 9: //Botão Pesquisar

MessageBox.Show("Rotinas referentes à Pesquisa ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 10: //Botão Impressão

MessageBox.Show("Rotinas referentes à Impressão ! ", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);

break;

case 12: //Botão Sair

Close();

break;

}

No evento clique do “Toolstrip” iremos realizar um “Switch/Case” para verificar o componente clicado, permitindo ter um controle através do índice do mesmo. Importante salientar que estou apenas apresentando um “MessageBox” para identificar cada botão clicado.

É nesta parte do código que devemos implementar todo o código base de cadastro, inclusão, edição, pesquisa, etc... Fica aí a dica caro leitor!

Herdando o Formulário Base

Para herdar o formulário criado acima é muito fácil, no “WindowsFormsApp” clique com o botão direito sobre o mesmo escolhendo a opção “Adicionar/Novo Item/Windows Forms”. Escolha “Formulário Herdado” inserindo um Nome e por final clique no botão Adicionar. Ver Figura 06

Figura 06: Adicionar Formulário Herdado.

Veremos que o formulário não irá herdar mais da classe “Form” e sim da classe “FormularioPadrao”. Ver código abaixo.

public partial class FrmExemplo : FPadrao.FormularioPadrao

{

public FrmExemplo()

{

InitializeComponent();

}

Neste formulário poderemos adicionar quaisquer componentes, como por exemplo TextBox, Label, entre outros. Veremos na Figura 07 o projeto em Run-Time.

Figura 07: Projeto em run-time.

Conclusões

A herança de formulários é uma das características de boa prática de programação. No Microsoft Visual Studio esta tarefa se torna fácil e simples, nos auxiliando e agilizando muito na implementação de cadastros nos sistemas. Também foi apresentado neste mês a possibilidade tanto na parte gráfica (referentes a componentes) do formulário quanto na implementação de códigos padrões.

Fica a dica, um forte abraço e até o mês que vem!

Referências

https://fontawesome.com/

Sobre o autor

Thiago Cavalheiro Montebugnoli adora aprender novas tecnologias. Formado pela Faculdade de Tecnologia de Botucatu – SP (FATEC), já desenvolveu softwares utilizando a plataforma .NET, Delphi junto com Banco de Dados SQL Server e Firebird. Como experiências profissionais mais recentes, possui em seu currículo sua atuação no Centro de Processamento de Dados da Prefeitura Municipal de Itaí-SP e atualmente compõe a equipe da Coordenadoria Tecnologia da Informação no IFSP – Instituto Federal do Estado de São Paulo em Avaré. Além disso, é colunista mensal da Revista The Club Megazine e é consultor Técnico do The Club. Possui as seguintes certificações: MCP - Microsoft Certified Professional, MCTS - Microsoft Certified Technology Specialist, MCAD - Microsoft Certified Application Developer e MCSD - Microsoft Certified Solution Developer.

Microsoft Visual Studio 2017 - Utilizando o framework Materialize

2019-11-13T23:03:00.005-03:00

Caro leitor,

Neste mês de Março irei discutir um pouco sobre deste framework moderno e responsivo baseado no Material Design (Para quem não sabe, o mesmo design utilizado no sistema operacional para smartphones, tables Android desde a versão 5.0). Criado e projetado pelo Google, o Material Design é uma linguagem de design que combina os princípios clássicos do design bem-sucedido com a inovação e a tecnologia. O objetivo do Google é desenvolver um sistema de design que permita uma experiência de usuário unificada em todos os seus produtos em qualquer plataforma.

De acordo com sua documentação oficial, o Materialize possui alguns princípios, tais como: “Material é a metáfora”, o qual define a relação entre espaço e movimento, sendo que a ideia é que a tecnologia é inspirada em papel e tinta facilitando a criatividade e inovação.“Ousado, gráfico e intencional” significa que elementos e componentes como grids, tipografia, cores, e imagens não são apenas visualmente agradáveis mas também criam um senso de hierarquia, significado e foco. A ênfase em diferentes ações e componentes criam um guia visual para os usuários. “Movimento fornece significado” permite ao usuário traçar um paralelo entre o que eles vêem na tela e na vida real. Para maiores detalhes recomendo a leitura de sua vasta documentação encontrada no link do final do artigo.

Este Framework pode ser facilmente implementado na plataforma .NET, e é por este caminho que iremos hoje. Implementaremos o Materialize junto com o Microsoft Visual Studio 2017 através de um novo “Web Site Asp.Net”. Faremos o uso também do famigerado gerenciador de pacotes NuGet, o qual facilitará nosso trabalho de instalação e configuração do mesmo.

Criando um novo projeto

Inicie o MVS2017 clicando no menu “Arquivo/Novo Projeto/Web Site/Web Site Vazio...” definindo um nome para o projeto. Adicione um “Web Form” dando um clique com o botão Botão direito sobre a solução, “Adicionar/Formulário Web”. Para aplicarmos algumas classes deste framework, criaremos um pequeno exemplo de cadastro contendo um Menu, alguns campos como Nome, SobreNome, E-mail,Endereço e Observações e por final um Botão Cadastrar.

Atenção: Este artigo Implementará apenas a parte visual do cadastro, o “Front-End”.

Instalando o “Materialize”

Com o projeto criado partiremos para a instalação do framework. Os passos são idênticos aos dos artigos anteriores que fazem o uso do NuGet. Clique no menu “Ferramentas/Gerenciador de Pacotes do NuGet/Gerenciar Pacotes do NuGet para a Solução...”. Na aba “Procurar” pesquise por “Materialize”, geralmente é o primeiro encontrado. Para instalá-lo clique na região direita no Botão “Instalar”. Ver Imagem 01.

Figura 01: Instalação do Materialize.

O framework Materialize utiliza como base o Jquery, automaticamente será instalado como pré-requisito para o funcionamento adequado do mesmo. No nosso caso foi instalada a versão “JQuery 2.1.1”.

Após o término da instalação será aberto um arquivo “Readme.txt” com algumas dicas iniciais para o uso do Materialize, como por exemplo sua importação. Podemos conferir mais detalhes na Imagem 02.

Figura 02: Gerenciador de Soluções com o Materialize instalado.

Codificando o Exemplo

Por padrão quando é criada uma página do tipo Web as principais TAGs já estão inclusas. Seguindo a documentação do Materialize precisaremos adicionar algumas referências para o bom funcionamento do mesmo.

Na Tag “Head” importaremos o arquivo “CSS” do Materialize, encontrada na pasta “content/materialize/css/materialize.min.cs”. Este arquivo que será responsável pelo agradável visual de nosso formulário. Ainda na nesta mesma Tag iremos adicionar o código responsável para uma total otimização com o celular, com a Meta Tag “viewreport”, preencheremos com algumas propriedades como “width-device-width”, “initial-scale=1.0”, “maximum-scale=1.0”, “user-scalable=no”, todas propriedades específicas do Materialize.

Ver Listagem 01 com as principais regiões do código destacada.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

<!DOCTYPE html>

<title>The Club - Materialize</title>

</head>

Na Tag “Body” faremos a referência ao “JQuery”, um script necessário para o funcionamento do framework, e logo em seguida o próprio “Materialize.js”. Usaremos a Tag “<script>”. Ver Listagem 2

O framework Materialize funciona através da implementação de classes, ou seja, teremos classes específicas para o cabeçalho, logo, menus, caixas de textos, etc... Abaixo irei descrever os principais recursos para criar um visual bonito em uma página Web. Toda a codificação deverá ser implementada na Tag “Body”, que será o corpo de nossa página.

<nav>

<label class="brand-logo">The Club - O maior clube de programadores do Brasil</label>

<li><a href="inicio.aspx">Início</a></li>

<li><a href="cadastro.aspx">Cadastro</a></li>

<li><a href="manutencao.aspx">Manutenção</a></li>

</ul>

</div>

</nav>

Dentro da Tag “Nav” será montado o cabeçalho. Como foi dito anteriormente, o Materialize faz referências através de classes, portanto inserimos a propriedade “class=”. Colocaremos uma “div” e dentro da mesma criaremos um “label” com o título seguido de uma lista de links. Usaremos a classe “nav-wrapper”, “brand-logo” e “right hide-on-med-and-down” respectivamente. Ver Imagem 03.

Figura 03: Cabeçalho.

A próxima etapa será a de adicionar os campos necessários junto com o botão “Cadastrar”. Crie uma “div” usando a classe “row” e dentro desta implementaremos a tag “form” com a classe “col s12”.

</div>

<label for="sobrenome">Sobrenome</label>

</div>

</div>

<label for="endereco">Endereço</label>

</div>

<label for="observacoes">Observações</label>

</div>

<div class="center-align"><button class="btn waves-effect waves-light" type="submit" name="action">Cadastrar</button></div>

</form>

</div>

</body>

</html>

Todos os campos serão compostos por uma div “row” principal contendo outra denominada “input-field col s6” ou “input-field col s12”. O número 06 ou 12 indica o tamanho do “Input” que será mostrado na tela. A tag “input” ou “textarea” criará a caixa de texto, já a “label” o descritivo deste campo. Ver Imagem 04 para maiores detalhes.

Figura 04: Tamanhos de campos.

Por final, no “button” usaremos a classe “btn waves-effect waves-light” para uma aparência agradável. Figura 05.

Figura 05: Botão cadastrar.

O projeto em funcionamento poderemos conferir na Figura 06.

Figura 06: Web Form em funcionamento.

Conclusões

O framework “Materialize”, baseado no “Material Design” da grande Google está presente em muitos sites importantes, podendo ser conferido em sua documentação citada nas referências. Assim como o Bootstrap, este framework nos auxilia e nos poupa muito trabalho em se tratando de desenvolvimento “Front-End”, pela sua facilidade nas implementações das classes específicas para cada momento além do lindo visual para o usuário.

Neste artigo procurei desenvolver um pequeno exemplo agregando as principais classes de formatações, deixando como base de estudo para projetos maiores. Não podemos esquecer que o mesmo foi instalado e configurado a partir do gerenciador de pacotes NuGet, uma poderosa ferramenta do Microsoft Visual Studio.

Desejo uma ótima leitura, um abraço e até o mês que vem!

Referências

http://materializecss.com/

Sobre o autor

Linguagem C# - Integração com o Active Directory do Windows Server

2019-10-16T22:41:00.000-03:00

Caro amigo leitor,

Neste mês irei abordar o assunto sobre a integração do AD(Active Directory) com aplicações .NET. O Active Directory é uma implementação de serviço de diretório no protocolo LDAP (Lightweight Directory Access Protocol) que é um protocolo de aplicação aberto, livre de fornecedor e padrão de indústria para acessar e manter serviços de informação de diretório distribuído sobre uma rede de Protocolo da Internet (IP). (Fonte: https://pt.wikipedia.org/wiki/LDAP)

O Active Directory armazena informações sobre objetos em rede de computadores, usuários, grupos, senhas, contas de computadores, unidades organizacionais. Uma das necessidades de sua criação foi a unificação de usuário para acessar diferentes recursos como: sistemas, e-mails, logar no computador. Em poucas palavras, o mesmo se comporta como um grande Banco de Dados destas informações.

É importante salientar que o Active Directory está presente nos Sistemas Operacionais da Microsoft desde sua versão 2000, lembrando que para instalá-lo e utilizá-lo deveremos ter uma licença do mesmo.

A plataforma .NET fornece algumas bibliotecas nativas para trabalhar com o AD oferecendo uma total compatibilidade com o mesmo, facilitando a vida de nós programadores. Neste artigo criarei um exemplo utilizando Formulários Windows (Windows Forms) junto com o Microsoft Visual Studio Community 2017 com a liguagem C#. Usarei também o Windows Server 2012 R2. Demonstrarei todos os passos para criar um usuário contendo todas as propriedades necessárias dentro de uma Unidade Organizacional (As famosas OUs)

Criando um novo projeto

Inicie um novo projeto clicando em “Arquivo/Novo/Projeto...” escolhendo a opção “Aplicativo do Windows Forms”. Defina um nome e local de sua preferência clicando no botão “Ok” para finalizar. O nosso formulário deverá conter três campos do tipo “TextBox” para inserção (Id, Nome, Sobrenome), um campo do tipo “Combobox” (Listar as Unidades Organizacionais - OU), um “Button“ denominado “Cadastrar” para execução dos comandos e um “ListBox” para demonstrar os cadastros efetuados. Para maiores detalhes confira a Imagem 01.

Figura 01: Formulário de Integração.

Criando uma OU (Unidade Organizacional)

Acesse o Windows Server e na “Central Administrativa do Active Directory” clique na região esquerda do domínio desejado e com o botão direito escolha “Novo/Unidade Organizacional”. No nosso caso foi inserido “TESTE_C”. Lembrando que nossos usuários ficarão armazenados dentro desta propriedade. Ver imagem 02.

Figura 02: Criando a Unidade Organizacional.

Codificando o Exemplo

Partiremos para a codificação do projeto, o primeiro passo seria adicionar a biblioteca específica para esta tarefa, a “System.DirectoryServices” logo em seguida criaremos alguns métodos para trabalhar, exemplo: AdicionarUsuario(), ListarTodosUsuarios() e ListarOus().

using System.Windows.Forms;

using System.DirectoryServices;

namespace WindowsFormsApp1

{

public partial class FrmImport : Form

{

public const string nomeDominio = "LDAP://theclub.avare.edu";

Criaremos uma constante com o nome do domínio,contendo a estrutura de exemplo acima.

public FrmImport()

{

InitializeComponent();

}

O método construtor “FrmImport()” é padrão em todos os formulários Windows.

private void FrmImport_Load(object sender, EventArgs e)

{

ListarOus();

}

No evento “Load()” iremos alimentar a combobox contendo as Unidades Organizacionais de nosso domínio. Por isto invoque o método “ListarOus” que comentaremos logo abaixo.

private void ListarOus()

{

cbOus.Items.Clear();

DirectoryEntry diretorio = new DirectoryEntry(nomeDominio);

DirectorySearcher pesquisa = new DirectorySearcher(diretorio);

pesquisa.Filter = "(objectCategory=organizationalUnit)";

foreach (SearchResult res in pesquisa.FindAll())

{

string ou = res.Path;

int tamOu = ou.IndexOf(",DC") - ou.IndexOf("OU=");

string ouNew = ou.Substring(ou.IndexOf("OU="), tamOu);

cbOus.Items.Add(ouNew);

}

Primeiramente limparemos o componente Combobox através do método “Clear()”. Deveremos instanciar três objetos, sendo o “DirectoryEntry” contendo o caminho do domínio (constante nomeDominio), “DirectorySearcher” responsável pela pesquisa dentro do domínio e o método “Filter” para filtrarmos todos os objetos da categoria “organizationalUnit”. Faremos um Foreach para localizarmos apenas a substring contendo o nome das “Ous” cadastradas no Windows Server.

private bool AdicionarUsuario(string accountName, string givenName, string surName, string displayName)

{

DirectoryEntry obDominio = null;

try

{

obDominio = new DirectoryEntry(nomeDominio);

DirectoryEntries entrada = obDominio.Children;

DirectoryEntry dados = entrada.Add("CN="+displayName+","+ cbOus.Text, "User");

dados.Properties["samAccountName"].Add(accountName); dados.Properties["givenName"].Add(givenName);

dados.Properties["sn"].Add(surName);

dados.Properties["displayName"].Add(displayName);

dados.CommitChanges();

return true;

}

catch

{

return false;

}

O método booleano “AdicionarUsuario” irá possuir alguns parâmetros de entrada como: accountName para incluir o ID, givenName para o campo Nome, surName para o SobreNome e displayName para o Nome Completo. É bom lembrarmos que estas propriedades são chaves específicas da estrutura do AD. Dentro de um “Try/Catch” faremos todo o trabalho de inclusão, instanciando os objetos “DirectoryEntry” e “DirectoryEntries”. Para incluir os dados contidos nos parâmetros criaremos um objeto do tipo “DirectoryEntry” e através do método “Add” podemos concluir esta tarefa. Para finalizar execute o “CommitChanges()”.

private void ListarTodosUsuarios()

{

lstUsuarios.Items.Clear();

DirectoryEntry diretorio = new DirectoryEntry(nomeDominio);

DirectorySearcher pesquisa = new DirectorySearcher(diretorio, cbOus.Text);

SearchResult resultado = pesquisa.FindOne();

if (resultado != null)

{

DirectoryEntry entrada = resultado.GetDirectoryEntry();

foreach (DirectoryEntry dir in entrada.Children)

{

string usuario = dir.Name;

lstUsuarios.Items.Add(usuario);

}

Já o método “ListarTodosUsuarios()” terá a tarefa de demonstrar os usuários cadastrados na determinada “OU”. Faremos a instância do objeto “DirectoryEntry”, “DirectorySearcher” e “SearcherResult”. Iremos adicionar os usuários no “ListBox” através de um “Foreach” com o auxílio da propriedade “dir.Name”.

private void btnCadastrar_Click(object sender, EventArgs e)

{

lstUsuarios.Items.Clear();

if (txtId.Text.Length <= 0)

{

MessageBox.Show("Para proceder é necessário informar o Id do usuário!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);

txtId.Focus();

return;

}

if (txtNome.Text.Length <= 0)

{

MessageBox.Show("Para proceder é necessário informar o Nome do usuário!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);

txtNome.Focus();

return;

}

if (txtSobrenome.Text.Length <= 0)

{

MessageBox.Show("Para proceder é necessário informar o Sobrenome do usuário!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);

txtSobrenome.Focus();

return;

}

if (cbOus.SelectedIndex < 0)

{

MessageBox.Show("Para proceder é necessário selecionar uma OU!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);

cbOus.Focus();

return;

}

if (AdicionarUsuario(txtId.Text, txtNome.Text, txtSobrenome.Text, txtNome.Text + " " + txtSobrenome.Text) == false)

MessageBox.Show("Erro no Cadastro!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Information);

ListarTodosUsuarios();

}

No evento “Click” do “Button” realizaremos algumas consistências nos campos Id, Nome, Sobrenome e Ou. Testaremos se os mesmos não estão vazios. Invocaremos o método supracitado “AdicionarUsuario” informando todos os parâmetros necessários, resultando em um valor booleano. Caso ocorra algum erro informaremos ao usuário através de um “MessageBox”. Finalizaremos com o método “ListarTodosUsuarios()”

Podemos conferir o projeto em run-time na Imagem 03.

Figura 03: Exemplo em run-time.

No Windows Server teremos o registro inserido com sucesso. Ver Figura 04.

Figura 04: Usuário criado no AD.

Conclusões

O uso do Active Directory do Windows Server é muito comum nas empresas que possuem controle de usuários, pela sua facilidade e qualidade em se tratando deste tipo de serviço. A plataforma .NET fornece uma total compatibilidade com o mesmo, disponibilizando bibliotecas nativas, como por exemplo a System.DirectoryServices. Com o uso desta biblioteca foi criada um pequena aplicação para cadastro de usuários no AD, informando alguns campos mais comuns para um fácil aprendizado.

Fica a dica, um abraço e até o mês que vem!

Sobre o autor

Android – Apresentando a classe LocationManager

2019-05-23T10:53:00.000-03:00

Caro amigo leitor, neste artigo irei apresentar algumas funcionalidades da classe “LocationManager” do Sistema Android, nos permitindo obter facilmente informações sobre posições geográficas através da latitude, longitude, entre outros atributos. Podemos utilizar o GPS, Wi-fi ou qualquer plano de dados como exemplo de “provedores de localização”. Para este artigo estarei utilizando o próprio Wi-fi para obter estes dados. Criarei um pequeno exemplo abrangendo todos os passos para utilizar corretamente esta classe.

Criando o Exemplo

Iniciaremos um projeto do zero clicando em “File/New/New Project...” definindo um nome qualquer, como por exemplo: “LocatioManager”. Defina a API 23 (Android 6) como SDK mínimo e uma “Activity” em branco. Teremos a estrutura básica conforme ilustra a Imagem 01.

Figura 01: Projeto Inicial.

Configurando o “AndroidManifest.xml”

Faremos duas implementações neste arquivo de configuração, sendo a primeira para acesso as permissões de localização pela rede (android.permission.ACCESS_COARSE_LOCATION) e a segunda para acessar a localização pela rede e GPS do dispositivo (android.permission.ACCESS_FINE_LOCATION). Abaixo demonstrarei todas as informações necessárias. Listagem 01.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="exemplo.locationmanager" >

    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
Listagem 01.

Criando o Lay-out

O nosso lay-out será composto de um “Button” para obter a localização através do objeto “LocationManager” seguido de quatro “TextViews” com os seguinte dados: Latitude, Longitude, Data/Hora e Precisão. Confira estes detalhes na Imagem 02.

Figura 02: Layout proposto.

Teremos o XML correspondente abaixo: (Listagem 02)

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context="exemplo.locationmanager.MainActivity"
    android:weightSum="1">

    <Button
        android:text="Obter Localização"
        android:id="@+id/btnObterLocalizacao"
        android:layout_width="222dp"
        android:layout_height="wrap_content"
        android:onClick="ObterLocalização"
        android:gravity="center_vertical|center_horizontal|center"
        android:layout_gravity="center"/>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <TextView
            android:text="Latitude:"
            android:textStyle="bold"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtlbLatitude" />
        <TextView
            android:text="0.00"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtLatitude" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <TextView
            android:text="Longitude:"
            android:textStyle="bold"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtlbLongitude" />
        <TextView
            android:text="0.00"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtLongitude" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <TextView
            android:text="Data/Hora:"
            android:textStyle="bold"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtlbDataHora" />
        <TextView
            android:text="99/99/9999 99:99:99"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtDataHora" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="horizontal">
        <TextView
            android:text="Precisão:"
            android:textStyle="bold"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtlbPrecisao" />
        <TextView
            android:text="0.00"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginTop="16dp"
            android:id="@+id/txtPrecisao" />
    </LinearLayout>
</LinearLayout>
Listagem 02.

Para o layout utilizei como padrão o tipo “LinearLayout” com orientação “Vertical”, seguindo dos componentes “TextViews” para cada tipo de informação desejada.

Codificando o Exemplo

O exemplo terá como base o Método “ObterLocalização” o qual será invocado no evento “OnClick” do “Button” para setar as propriedades: Latitude, Longitude, Data/Hora e Precisão.

Primeiramente deveremos importar algumas bibliotecas essenciais para o bom funcionamento, segue abaixo:

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.support.v4.app.ActivityCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import java.text.SimpleDateFormat;

Teremos algumas, tais como: “location.Location”, “location.LocationListener” e “location.LocationManager” que servirão diretamente à nossa classe LocationManager. Usaremos também outras para suporte a compatibilidade de aplicativos (“support.v4.app.ActivityCompat” e “support.v7.app.AppCompatActivity”), etc ... Não entrarei em maiores detalhes, pois as outras já foram abordadas em artigos anteriores.

public class MainActivity extends AppCompatActivity
{
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

O método “OnCreate” irá instanciar e inflar nosso lay-out.

    public void ObterLocalizacao(View v)
    {
        LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

Instanciaremos indiretamente a classe “LocationManager” a recuperando através do método “getSystemService (Context.LOCATION_SERVICE)”

if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED &&

ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED)
{
return;
}

Aproveitaremos também para realizar uma verificação de permissão de acesso com o método “CheckSelfPermission”, o qual irá analisar se a permissão foi realizada com sucesso no arquivo “AndroidManifest”.

locationManager.requestSingleUpdate(LocationManager.NETWORK_PROVIDER, new LocationListener()

{

A interface “LocationListener” recebe como parâmetro o tipo de provedor (no nosso caso usaremos a internet) que nos obriga a implementar os seguintes métodos: (“OnStatusChanged”, o qual será disparado quando o Status da localização for alterado, “OnProviderEnabled”, o qual indica se o Provider está Habilitado, “OnProviderDisabled” indicando se o mesmo está desabilitado e por último o “OnLocationChanged” que abordarei logo abaixo).

    @Override
    public void onStatusChanged(String arg0, int arg1, Bundle arg2)
    {
         //Método disparado quando o status for alterado
    }

    @Override
    public void onProviderEnabled(String arg0)
    {
        //Método indica o Provider Habilitado
    }

    @Override
    public void onProviderDisabled(String arg0)
    {
        //Método indica o Provider Desabilitado
    }

    @Override
    public void onLocationChanged(Location location)
    {
      TextView latitude = (TextView) findViewById(R.id.txtLatitude);
      TextView longitude = (TextView) findViewById(R.id.txtLongitude);
      TextView datahora = (TextView) findViewById(R.id.txtDataHora);
     TextView precisao = (TextView) findViewById(R.id.txtPrecisao);

      if (location != null)
      {
       latitude.setText(String.valueOf(location.getLatitude()));
       longitude.setText(String.valueOf(location.getLongitude()));
       precisao.setText(String.valueOf(location.getAccuracy()));
       SimpleDateFormat data = new SimpleDateFormat("dd / MM / yyyy HH: mm: ss");
       datahora.setText(data.format(location.getTime()));
      }
    }
   }, null);
}
}

Recebemos via parâmetro o objeto “location”, criaremos as variáveis do tipo “TextView” para receber os dados e através de uma verificação se este objeto está nulo. Setaremos os valores usando os métodos “getLatitude()” para obter a Latitude, “getLongitude()” para obter a Longitude, “getAccuracy()” para obter a precisão e “getTime()” para obter a Data e Hora.

Teremos um resultado idêntico ao da Figura 03.

Figura 03: Informações Geográficas.

Conclusões

Procurei neste artigo explorar de uma forma prática o uso da classe “LocationManager”, seguido de um pequeno exemplo de sua utilização no dia-a-dia. Usei como provedor o próprio Wi-fi, ressaltando que também poderíamos ter utilizado qualquer plano de dados, ou o próprio GPS do telefone celular, tablet.

Fica aí a dica, um abraço e até o mês que vem!

Referências

https://developer.android.com/reference/android/location/LocationManager.html

Sobre o autor

Android – Trabalhando com o RecyclerView

2019-05-23T10:49:00.001-03:00

Caro leitor, este mês continuarei trabalhando com dicas para desenvolver com a ferramenta Android Studio. Utilizaremos o widget “RecyclerView” em conjunto com o “CardView”. Para quem não conhece este último, recomendo a leitura do artigo “Conhecendo e Utilizando o CardView” do mês de Janeiro de 2017.

O “RecyclerView” tem a função de exibir uma listagem de dados para o usuário, assim como o antigo “ListView”, o qual também possui esta funcionalidade. De acordo com sua documentação oficial, temos algumas vantagens deste widget, tais como:

- Animações padrões para operações de itens comuns, para remoção ou adição de itens;

- Modularização, ou seja, podemos inserir comportamentos no mesmo intercambiando componentes internos da View;

- É mais performático, ou seja, implementa a classe ”ViewHolder” impedindo algumas chamadas do método “findViewById” desnecessariamente. Teremos um nível de abstração maior entre a lista de dados do usuário e a ‘View”, deixando assim o componente mais performático.

Na Figura 01 podemos conferir a estrutura hierárquica.

Figura 01: Estrutura Hierárquica.

Para entendermos melhor, montaremos um exemplo prático criando uma classe de Produtos com alguns atributos, tais como: Id, Nome e Valor, um arquivo de layout contendo a estrutura completa destes atributos seguido de um “CardView” para organização e a classe “Adapter” do “RecyclerView”, o qual fará toda a tarefa interna da classe “Produtos”.

Importando a Biblioteca

Recomendo criar um projeto do início defindo um nome para o mesmo, no nosso caso defini como “appRecyclerView”. Teremos a estrutura padrão, contendo a classe “MainActivity” e o layout “activity_main”. No arquivo de configuração “build.gradle” iremos inserir as dependências do “RecyclerView” juntamente com a “CardView”. (No artigo do mês passado abordo esta técnica com maiores detalhes). O trecho da codificação ficará da seguinte maneira:

dependencies

{
    . . .
    compile 'com.android.support:appcompat-v7:24.1.1'
    compile 'com.android.support:cardview-v7:24.1.1'
    compile 'com.android.support:recyclerview-v7:24.1.1'
    . . .
}

Criando um exemplo prático

Antes de partirmos para codificação da classe principal “MainActivity”, criaremos alguns pré-requisitos como a: Classe “Produtos” (onde o usuário irá inserir os dados) e o layout “componente_produtos” (será responsável pela organização na tela do dispositivo).

Classe Produtos

Para criar uma classe clique com o botão direito sobre o pacote do projeto escolhendo “New/Java Class”. Defina como “Produtos”, teremos uma codificação idêntica da listagem 01.

package exemplo.apprecyclerview;

public class Produtos
{
   private int Id;
   private String Nome;
   private double Valor;

   public int getId()
   {
     return Id;
   }

   public void setId(int id)
   {
      Id = id;
   }

   public String getNome()
   {
      return Nome;
   }

   public void setNome(String nome)
   {
      Nome = nome;
   }

   public double getValor()
   {
      return Valor;
   }

   public void setValor(double valor)
   {
      Valor = valor;
   }
   public Produtos()
   {
      super();
   }
}
Listagem 01.

Layout “componente_produtos”

Para criar itens do tipo Layout localize o caminho “res/layout” escolhendo “New/Layout Resource File”. Defina o nome para “componente_produtos”. Confira o layout na Figura 02 e codificação na Listagem 02.

Figura 02: Layout do componente.

O XML correspondente:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <android.support.v7.widget.CardView
        android:id="@+id/card_view"
        android:foreground="?android:attr/selectableItemBackground"
        android:layout_gravity="center"
        android:clickable="true"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:orientation="horizontal"
            android:padding="5dp">
            <LinearLayout
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:orientation="vertical">
                <LinearLayout
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:orientation="horizontal">
                    <TextView android:id="@+id/complblId1"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="Id: "
                        android:textStyle="bold"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                    <TextView android:id="@+id/comptxtId1"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                </LinearLayout>

                <LinearLayout
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:orientation="horizontal">
                    <TextView android:id="@+id/complbNome2"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="Nome: "
                        android:textStyle="bold"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                    <TextView android:id="@+id/comptxtNome2"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                </LinearLayout>

                <LinearLayout
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:orientation="horizontal">
                    <TextView android:id="@+id/complbValor3"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:text="Valor: "
                        android:textStyle="bold"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                    <TextView android:id="@+id/comptxtValor3"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:textAppearance="?android:attr/textAppearanceSmall" />
                </LinearLayout>
            </LinearLayout>
        </LinearLayout>
    </android.support.v7.widget.CardView>
</LinearLayout>

Listagem 02.

Adicionamos um “CardView” e dentro do mesmo distribuímos os “Layouts” responsáveis por organizar os TextViews (Id, Nome e Valor).

Codificação na Classe “MainActivity”

Toda classe principal também possuirá um retorno em um arquivo de layout. Primeiramente iremos inserir o widget “RecyclerView” neste layout. Veja Imagem 03.

Figura 03: Layout “activity_main”.

O XML Correspondente:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    tools:context="exemplo.apprecyclerview.MainActivity">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/rvProdutos"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
</RelativeLayout>
Listagem 03.

Na “MainActivity” Teremos a codificação abaixo comentada nas principais regiões.

package exemplo.apprecyclerview;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;

Deveremos importar algumas bibliotecas, tais como a “LinearLayoutManager” responsável pela configuração do Layout, o “RecyclerView” para trabalhar com este componente, entre outras.

public class MainActivity extends AppCompatActivity {

    private List<Produtos> lstProdutos = new ArrayList<>();
    private RecyclerView rvProdutos;
    private ProdutosAdapter adpProdutos;
    private RecyclerView.LayoutManager layoutProdutos;

Usaremos algumas variáveis privadas, sendo a “lstProdutos” para englobar a classe Produtos através de um “ArrayList”, a “rvProdutos” para realizar a referência ao “RecyclerView”, a “adpProdutos” para armazenar os dados da classe Produtos e por último a “layoutProdutos”, a qual qual irá organizar os dados de uma forma mais eficaz.

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        rvProdutos = (RecyclerView) findViewById(R.id.rvProdutos);

        List<Produtos> listaprodutos = new ArrayList<Produtos>();
        Produtos produtos = new Produtos();
        produtos.setId(1);
        produtos.setNome("Abacaxi");
        produtos.setValor(1.99);
        listaprodutos.add(produtos);

        Produtos produtos2 = new Produtos();
        produtos2.setId(2);
        produtos2.setNome("Laranja");
        produtos2.setValor(3.59);
        listaprodutos.add(produtos2);

        Produtos produtos3 = new Produtos();
        produtos3.setId(3);
        produtos3.setNome("Melão");
        produtos3.setValor(4.99);
        listaprodutos.add(produtos3);

        lstProdutos = listaprodutos;
        layoutProdutos = new LinearLayoutManager(this);
        adpProdutos = new ProdutosAdapter(lstProdutos);
        rvProdutos.setAdapter(adpProdutos);
        rvProdutos.setLayoutManager(layoutProdutos);
        adpProdutos.notifyDataSetChanged();
    }

No método “OnCreate”, após a chamada do método “setContentView(R.layout.activity_main)”, iniciaremos o componente “RecyclerView” pelo método “FindViewById”. Instanciaremos a classe “Produtos” para inserir alguns dados aleatórios para setar na variável “lstProdutos” logo em seguida. Definiremos um “Layout” com o auxílio do “LinearLayoutManager”. O adapter “adpProdutos” será alimentado pelo método da classe “ProdutorAdapter”, a qual será implementada logo abaixo. Setaremos também o adapter e layout em nosso rvProdutos (RecyclerView).

public class ProdutosAdapter extends RecyclerView.Adapter<ProdutosAdapter.MyViewHolder> {

private List<Produtos> ListaProdutos;

Teremos que criar a variável “List<Produtos>” para trabalharmos com o Adapter “ProdutosAdapter”. Extenderemos a classe “RecyclerView.Adapter”, portanto seremos forçados a utilizar alguns métodos, os quais veremos logo adiante.

        public class MeuViewHolder extends RecyclerView.ViewHolder
        {
            public TextView Id, Nome, Valor;

            public MeuViewHolder(View view) {
                super(view);
                Id = (TextView) view.findViewById(R.id.comptxtId1);
                Nome = (TextView) view.findViewById(R.id.comptxtNome2);
                Valor = (TextView) view.findViewById(R.id.comptxtValor3);
            }
        }

A classe “MeuViewHolder” irá servir como suporte para definirmos a View, e os TextViews, sendo o Id, Nome e Valor.

        public ProdutosAdapter(List<Produtos> Produtos)
        {
            this.ListaProdutos = Produtos;
        }

O método acima irá armazenar os produtos.

        @Override
        public MeuViewHolder onCreateViewHolder(ViewGroup parent, int viewType)
        {
            View itemView = LayoutInflater.from(parent.getContext())
                    .inflate(R.layout.componente_produtos, parent, false);

            return new MeuViewHolder(itemView);
        }

Já o método sobrescrito “MeuViewHolder” irá criar nossa view usando o “LayoutInflater” com o parâmetro contexto inflando o layout “componente_produtos” criado anteriormente.

        @Override
        public void onBindViewHolder(MeuViewHolder holder, int position)
        {
            Produtos item = ListaProdutos.get(position);
            holder.Id.setText(String.valueOf(item.getId()));
            holder.Nome.setText(item.getNome());
            holder.Valor.setText(String.valueOf(item.getValor()));
        }

        @Override
        public int getItemCount()
        {
            return ListaProdutos.size();
        }
    }

No “onBindViewHolder”, pela posição do item, iremos alimentar o “MeuViewHolder”, o qual irá mostrar o resultado na tela do dispositivo móvel. Com nosso aplicativo rodando, teremos um resultado idêntico ao da Figura 04.

}

Figura 04: Exemplo funcionando.

Conclusões

Neste artigo procurei descrever através da criação de um exemplo, o funcionamento deste importante widget. Foi criada uma classe específica sobrescrevendo alguns métodos necessários para realização desta tarefa. Aproveitei e implantei funcionalidades básicas para obter um resultado melhor.

Fica aí a dica, um abraço e até o mês que vem!

Referências

https://developer.android.com/training/material/lists-cards.html?hl=pt-br#RecyclerView

https://developer.android.com/reference/android/support/v7/widget/RecyclerView.html?hl=pt-br

Sobre o autor

Android – Conhecendo e utilizando o CardView

2019-05-01T09:32:00.001-03:00

Caro leitor,

Primeiramente desejo a você um ótimo início de ano, com muita saúde, paz e sucesso profissional. Inicio este ano redigindo um artigo sobre a plataforma Android, sendo que neste abordarei o uso do widget “CardView”. Após analisar a documentação oficial, o cardview herda da classe “FrameLayout”, permitindo a exibição de informações dentro dos cartões, tendo uma aparência coerente nas diversas plataformas, podendo ser configurado sombras e bordas arredondadas. Na Figura 01 podemos conferir a estrutura da classe “android.support.v7.widget.CardView”.

Figura 01: Estrutura Hierárquica.

O “CardView” utiliza a propriedade de elevação (cardElevation) na versão “Lollipop” (Android 5.0, API nível 21) e posteriores. Para as versões mais antigas a implementação do efeito de sombra seria de forma emulada ou programática.

Principais Atributos

Nas próximas linhas irei descrever os atributos mais utilizados, confira os detalhes na Tabela 01.

Nome do atributo do XML	Descrição
android.support.v7.cardview:cardBackgroundColor	Cor de fundo do CardView, podendo ser um valor na forma “#rgb”, “#argb”, “ rrggbb”, etc ...
android.support.v7.cardview:cardCornerRadius	Configuração de dimensão de canto. As unidades disponíveis são: px (pixels), dp (pisels independentes, sp (pixels dimensionados com base na fonte), etc ...
android.support.v7.cardview:cardElevation	Elevação para o widget, seguindos as mesmas unidades descritas acima.
android.support.v7.cardview:cardMaxElevation	Elevação máxima, também seguindos as unidades supracitadas.
android.support.v7.cardview:cardPreventCornerOverlap	Preenchimento ao CardView na versão v20, assim evitando interseções entre o conteúdo do cartão e os cantos arredondados. Usaremos os valores booleanos: “true” ou “false”
android.support.v7.cardview:cardUseCompatPadding	Adicione o espaçamento a partir da versão API21, conseguindo uma compatibilidade para versões anteriores. Usaremos atributos booleanos para esta tarefa.
android.support.v7.cardview:contentPadding	Seria o interior entre as bordas do Cardview. Usaremos valores de pixels descritos anteriormente.
android.support.v7.cardview:contentPaddingBottom/ android.support.v7.cardview:contentPaddingLeft/ android.support.v7.cardview:contentPaddingRight/ android.support.v7.cardview:contentPaddingTop	Espaço interior entre a borda inferior, lateral esquerda, direita e superior respectivamente. Podemos utilizar como medidas os pixels descritos nos itens acima.

Tabela 01.

Principais Construtores

Teremos três principais construtores, sendo o:

CardView (Context context):
Passamos por parâmetros apenas o Contexto da aplicação.

CardView (Context context, AttributeSet attrs):
Informaremos por parâmetros o Contexto e valor da classe “AtributeSet”, que seria uma coleção de atributos, como os encontrados associados a uma tag em um documento XML.

CardView (Context context, AttributeSet attrs, int defStyleAttr):
No momento da criação usaremos os mesmos parâmetros citados anteriormente adicionados do atributo inteiro “defStyleAttr” que nada mais é do que um identificador para o atributo.

Principais Métodos

Teremos inúmeros métodos referentes à classe “CardView”. Abaixo destaquei alguns referentes ao retorno e outros de Atualização. Os famosos (Gets e Sets) da programação orientada a objetos. Ver Tabela 02.

Nome do Método	Descrição
getCardElevation()	Retorna um valor numérico a elevação do CardView.
getContentPaddingBottom()	Retorna um valor numérico do tipo inteiro do preenchimento interno antes da borda inferior do CardView. Temos os métodos getContentPaddingLeft(), getContentPaddingRight() e getContentPaddingTop() que possuem praticamente a mesma característica relacionada à região esquerda, direita e superior.
setCardElevation(float elevation)	Setar, atualizar a elevação do CardView.
setContentPadding(int left, int top, int right, int bottom)	Define o preenchimento entre as bordas do CardView.
setRadius(float radius)	Seta o raio de canto do widget.

Tabela 02.

Importando a Biblioteca

O primeiro passo para realizar a importação seria a criação de um novo projeto no Android Studio. Para isto clique em “File/New/New Project ...” Fiquem a vontade para inserir o nome como desejar, no meu caso foi criado com o nome “Cardview”. Para nossos testes também foi escolhido o SDK (API 23: Android 6.0 - Marshmallow).

Após a criação do projeto, localize o arquivo “build.gradle (Module: app)”, o qual foi gerado automaticamente. Entre as chaves { } do item “dependencies” insira o código abaixo e logo após clique no link “Sync Now” para reindexar o projeto com a bilioteca “CardView”. Confira os detalhes no código e na Imagem 02 abaixo.

Exemplo:

dependencies {

. . .



compile 'com.android.support:cardview-v7:24.1.1'

. . .

}

Figura 02: Adicionando a referência do CardView.

Criando um exemplo prático

Localize o arquivo de layout, por exemplo: “res/layout/activity_main.xml” o qual deverá estar provavelmente em branco, apenas com o componente de Layout. Para adicionar o componente “CardView” basta adicioná-lo com o auxílio da TAG “android.support.v7.widget.CardView” e dentro do mesmo iremos implementar uma “ImageView” junto com dois “TextViews”. Teremos o layout idêntico ao da Figura 03.

Figura 03: Layout Proposto.

Abaixo teremos o XML correspondente com explicações das principais partes do código.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="datasmart.cardview.MainActivity">

Para que o “CardView” funcione dentro de algum elemento de layout como um “RelativeLayout” ou um “LinearLayout”, o mesmo tem que conter a seguinte linha de identificação destacada acima.

    <android.support.v7.widget.CardView
        android:id="@+id/card_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_gravity="center"
        android:paddingBottom="10dp"
        android:paddingTop="10dp"
        app:cardBackgroundColor="@color/cardview_light_background"
        app:cardCornerRadius="4dp">

Teremos algumas configurações padrões como “android:id”, altura e largura do layout, entre outras configurações. Faremos algumas configurações pertinentes da classe “CardView” como por exemplo o “app:cardBackgroundColor” para alterar a cor de fundo e “app:cardCornerRadius” para definir o arredondamento de canto do componente.

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:orientation="vertical">

            <TextView
                android:id="@+id/txtTitulo"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:maxLines="1"
                android:paddingBottom="10dp"
                android:paddingLeft="20dp"
                android:paddingStart="20dp"
                android:paddingTop="5dp"
                android:text="DataSmart - Avaré/SP"
                android:textColor="@android:color/black"
                android:textSize="20dp"
                android:textStyle="bold"/>

            <ImageView
                android:id="@+id/imgBanner"
                android:layout_width="match_parent"
                android:layout_height="120dp"
                android:layout_below="@id/txtTitulo"
                android:scaleType="centerCrop"
                android:src="@drawable/imagem"/>

            <TextView
                android:id="@+id/description"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_below="@id/imgBanner"
                android:layout_centerVertical="true"
                android:layout_margin="4dp"
                android:gravity="center"
                android:maxLines="3"
                android:padding="10dp"
                android:text="Empresa que desenvolve softwares na área comercial para diversas plataformas."
                android:textColor="@color/button_material_dark"
                android:textSize="13dp" />

        </LinearLayout>

Já para o componente “ImageView” apenas definimos a Imagem, o layout e o tipo de escala. Para os componentes TextView não fazemos nada de diferente, apenas informamos um texto simples para uma fácil compreensão. É importante informar que ambos os componentes estão localizados dentro de um “LinearLayout” e o mesmo situado no interior de um “CardView”, o qual irá agrupá-los para uma melhor visualização.

</android.support.v7.widget.CardView>
</LinearLayout>

Podemos conferir o nosso aplicativo em run-time na Imagem 04.

Figura 04: Aplicativo em funcionamento.

Conclusões

Neste artigo foram descritos todos os principais atributos, métodos e construtores do componente “CardView”. Foi desenvolvido também um pequeno exemplo de como devemos utilizá-lo corretamente. Este tipo de widget é facilmente encontrado em praticamente todos os novos aplicativos, assumindo assim um papel importante de organização e distribuição de dados dentro de um layout.

Fica a dica aí pessoal, um grande abraço e até o mês que vem!

Referências

https://developer.android.com/training/material/lists-cards.html?hl=pt-br

Android - Utilizando a câmera – parte 2

2019-04-13T12:08:00.002-03:00

Caro amigo leitor, neste mês irei continuar escrevendo sobre a utilização de câmeras em dispositivos móveis, tendo como plataforma de desenvolvimento o Android Studio. No mês de Novembro, no artigo “Android – Utilizando a Câmera”, foi desenvolvido a classe base “CameraVisualizacao” a qual agrega alguns métodos e algumas funcionalidades básicas. Para este mês teremos como base o artigo do mês anterior com algumas mudanças na classe “CameraVisualizacao” e na Activity principal. A maior funcionalidade implementada será a capacidade de salvarmos a foto tirada pelo aplicativo. Então, mãos a obra.

Para isto separei este artigo com os seguintes tópicos:

- Modificação do arquivo “AndroidManifest.xml”

- Modificação do lay-out principal.

- Alteração e criação de novos métodos na classe “CameraVisualizacao”

- Implementação de novas rotinas na atividade principal “MainActivity”.

Criando o Exemplo

Seguindo como base o exemplo criado no mês passado, o primeiro passo seria a alteração do arquivo de configuração “AnroidManifest.xml”. Iremos inserir duas linhas conforme código destacado abaixo:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.thiago.appcamera">

    <uses-permission android:name="android.permission.CAMERA" />
    <uses-feature android:name="android.hardware.camera" />
    <uses-feature android:name="android.hardware.camera.autofocus" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

A funcionalidade “android.hardware.camera.autofocus”, irá nos possibilitar recuperar automaticamente o foco da imagem. Já o “android.permission.WRITE_EXTERNAL_STORAGE” irá permitir a gravação da foto em nosso dispositivo no formato em que desejarmos.

Modificação do lay-out principal

No nosso lay-out principal adicionaremos um “Button” para fotografar. Ver Imagem 01.

Figura 01. Layout Principal.

O XML correspondente poderemos conferir abaixo.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="15sp"
    >
    <SurfaceView android:id="@+id/area_view"
        android:layout_width="300sp"
        android:layout_height="0dp"
        android:layout_gravity="center_horizontal"
        android:layout_weight="1"
        />
    <Button android:id="@+id/bt_fotografar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Fotografar"
        />
</LinearLayout>

Alteração e criação de novos métodos na classe “CameraVisualizacao”

Implementaremos alguns novos métodos, como por exemplo o “TirarFoto” e declaramos algumas novas propriedades: a “visualizacao” e a “surfaceView”.

public class CameraVisualizacao implements SurfaceHolder.Callback
{
    private SurfaceHolder mHolder;
    private Camera mCamera;
    private SurfaceView surfaceView;
    private boolean visualizacao = false;

    public CameraVisualizacao(Activity atividade, int surfaceView)
    {
        this.surfaceView = (SurfaceView) atividade.findViewById(surfaceView);
        mHolder = this.surfaceView.getHolder();
        mHolder.addCallback(this);

    }

Inicializaremos a variável “surfaceview” para logo em seguida invocarmos o método “getHolder”. O “surfaceCreated” é chamado imediatamente após o “SurfaceHolder” ser criado.

    /**
     * @param holder
     */
    @Override
    public void surfaceCreated(SurfaceHolder holder)
    {
        mCamera = android.hardware.Camera.open();
        mCamera.setDisplayOrientation(90);
    }

Usaremos o método “Open” e o “setDisplayOrientation” para iniciar e definir uma orientação para a câmera.

    public void iniciarVisualizacao() {
        visualizacao = true;
        mCamera.startPreview();
    }

Inicia o Preview da Câmera.

    public void pararVisualizacao() {
        mCamera.stopPreview();
        visualizacao = false;
    }

Para o Preview da Câmera.

    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        if (visualizacao) {
            pararVisualizacao();
        }

        if (mCamera != null) {
            try {
                mCamera.setPreviewDisplay(mHolder);
                iniciarVisualizacao();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

Chamaremos o método “surfaceChanged” imediatamente após as alterações estruturais. Com o auxílio dos métodos “pararVisualizacao” e “iniciarVisualizacao” conseguimos parar e iniciar o preview da Câmera.

     *
     * @param holder
     */
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        pararVisualizacao();
        mCamera.release();
        mCamera = null;
    }

Usaremos este método para liberarmos o objeto “mCamera” da memória e pararmos o preview. Importante salientar que é chamado imediatamente antes do SurfaceHolder ser destruído.

    public void tirarFoto(Camera.ShutterCallback shutter, Camera.PictureCallback raw, Camera.PictureCallback jpeg) {
        mCamera.takePicture(shutter, raw, jpeg);
    }

}

Deveremo tratar a ação de tirar foto, como notamos, o método “tirarFoto()” recebe três parâmetros, sendo:

Camera.ShutterCallback shutter, Camera.PictureCallback raw, Camera.PictureCallback jpeg

O primeiro é referente a ação de tirar foto. Já o segundo e o terceiro é o retorno da imagem. Podemos recebê-la no formato RAW (segundo parâmetro) ou em JPEG (terceiro parâmetro), normalmente o modo RAW não é utilizado, por isso podemos passar o valor como null.

Implementação de novas rotinas na atividade principal “MainActivity”

O nosso controle será realizado por um “Button” e um “SurfaceView” conforme mencionado anteriormente.

import android.app.Activity;
import android.os.Environment;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Camera;

import java.io.File;
import java.io.FileOutputStream;

Usaremos algumas bibliotecas para trabalhar com Imagens, Câmeras e Arquivos. (Conforme Seleção acima)

public class CameraActivity extends Activity implements View.OnClickListener, Camera.ShutterCallback, Camera.PictureCallback {

Precisaremos da implementação de alguns métodos específicos da Câmera, conforme mencionado anteriormente.

    private CameraVisualizacao mCameraView;
    private boolean emCamera;
    private Button botaoCamera;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_camera);
        emCamera = true;
        mCameraView = new CameraVisualizacao(this, R.id.area_view);
        botaoCamera = (Button) findViewById(R.id.bt_fotografar);
        botaoCamera.setOnClickListener(this);
    }

“No evento OnCreate” inicializaremos a classe “CameraVisualizacao” passando os parâmetros “Activity” e a “SurfaceView“. Faremos o uso do evento “Onclick” do “Button”.

    public void onClick(View view)
    {
        switch (view.getId())
        {
            case R.id.bt_fotografar:
                if (emCamera)
                {
                    mCameraView.tirarFoto(this, null, this);
                }
                else
                {
                    emCamera = true;
                    botaoCamera.setText("Fotografar");
                    mCameraView.iniciarVisualizacao();
                }
                break;
        }
    }

No evento “onClick” analizaremos a variável booleana “emCamera” para Tirar Foto e Parar o Preview da Câmera.

    public void onShutter() {
        botaoCamera.setText("Câmera");
        emCamera = false;
    }

Este é o evento responsável pela ação do clique ao tirar a foto.

/*
     * @param bytes
     * @param camera
     */
    public void onPictureTaken(byte[] bytes, Camera camera) {

        Bitmap foto = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

        String arquivo = "theclub.png";
        File sd = Environment.getExternalStorageDirectory();
        File dest = new File(sd, arquivo);

        try {
            FileOutputStream out = new FileOutputStream(dest);
            foto.compress(Bitmap.CompressFormat.PNG, 90, out);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        mCameraView.pararVisualizacao();
    }
}

Já o evento “onPictureTaken” receberá como parâmetro uma variável do tipo “byte[]” e outra do tipo “Camera”. Criaremos um objeto “Bitmap” a qual armazenaremos em memória o conteúdo fotografado. Definiremos um nome para nossa foto (Ex: theclub.png) e com o comando “getExternalStorageDirectory” recuperaremos o diretório de nosso cartão “SD”. A classe “FileOutputStream” e a “File” fará o trabalho de gravar tudo que está na memória no diretório de nosso dispositivo móvel.

Podemos conferir o aplicativo funcionando na Imagem 02.

Figura 02: Aplicativo funcionando.

Conclusões

Além de implementar mais alguns recursos na classe “CameraVisualizacao”, pudemos aprender como fotografar e armazenar arquivos do tipo imagens em dispositivos móveis. Acredito que este exemplo servirá de base para quem desejar implantar este tipo de funcionalidade em seus sistemas.

Vou ficando por aqui. Um forte abraço e até o ano que vem!

Android - Utilizando a câmera

2019-04-13T12:06:00.000-03:00

Olá amigos do The Club, a partir deste mês começarei a redigir artigos práticos utilizando a ferramenta de desenvolvimento “Android Studio”. Recomendo a utilização desta IDE por se tratar da mais completa e atualizada quando o assunto se diz respeito aos dispositivos móveis com o Sistema Operacional Android. Um dos recursos mais usuais presentes nos disposivos móveis (tablets, celulares) é o uso da Câmera. Um exemplo quando desenvolvemos aplicativos, é a necessidade de fotografar um produto para mostrá-lo ao cliente. A partir disto, surgiu então a ideia de escrever este artigo, abordando todas as etapas para implementar este tipo de funcionalidade. Este primeiro irá criar a classe “Camera” junto com os lay-outs necessários apenas para a apresentação da Câmera dentro de uma “Activity”.

Estarei utilizando o “Android Studio 2.2.2” Build de Outubro de 2016 e o “Java 1.8.0_111”. Preparei o aplicativo para ser rodado a partir do Android 4.1. (Por se tratar de uma versão mais estável e muito utilizada entre nossos leitores)

Organizei o artigo da seguinte forma:

- Modificação do arquivo “AndroidManifest.xml”

- Criação do lay-out principal.

- Implementação da classe “CameraVisualizao”

- Implementação da atividade principal “MainActivity”.

Criando o Exemplo

Abra o Android Studio clicando em “File/New Project...” para a criação de um novo projeto. O primeiro passo seria atribuir um nome para a aplicação (Ex: AppCamera), um domínio (Ex: thiago.example.com), Nome do Pacote (Ex: com.example.thiago.appcamera) e Localização (Ex: C:\users\Thiago\AndroidStudioProjects\AppCamera). Fiquem a vontade para configurar o projeto da forma que desejar. Ver Figura 01.

Figura 01: Configurações Iniciais.

Na próxima tela definimos a versão da API do Android utilizada, ex: API 16 – Android 4.1 (Jelly Bean). No próximo passo conseguimos implementar algumas pré-configurações em nossa “Activity”. Costumo escolher a opção “Empty Activity”, q qual irá criar uma atividade vazia. Ver Imagem 02.

Figura 02: Criando a Activity.

Finalizamos a criação do projeto com o nome da Atividade principal. (Ex: MainActivity.java)

Modificação do arquivo “AndroidManifest.xml”

Deveremos adicionar duas linhas importantes neste arquivo responsáveis por permitir o uso e implementação da câmera no aplicativo.Ver listagem 01 com o código identificado.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.thiago.appcamera" >

   <uses-permission android:name="android.permission.CAMERA" />
    <uses-feature android:name="android.hardware.camera" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme" >
        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Listagem 01.

Criação do lay-out principal.

O nosso lay-out principal será composto por um “FrameLayout” e dentro do mesmo mais um “Framelayout” e um “ImageButton”. Assim teremos a câmera ocupando a tela toda da tela do dispositivo e com um pequeno botão (X) para fechar o aplicativo. Ver Imagem 03.

Figura 03: Lay-out proposto.

Implementação da classe “CameraVisualizao”

A classe supracitada será responsável por englobar todos os métodos principais para o funcionamento de nossa câmera. Primeiramente deveremos importar algumas bibliotecas essenciais para o bom funcionamento. Listagem 02.

import android.content.Context;

import android.hardware.Camera;

import android.util.Log;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import java.io.IOException;

public class CameraVisualizacao extends SurfaceView implements 
SurfaceHolder.Callback

{

Esta classe pública CameraVisualizacao irá herdar da “SurfaceView” e implementar da 
“SurfaceHolder.Callback” declarando os métodos: “SurfaceCreated”, “SurfaceChanged” e 
“SurfaceDestroyed”

    private SurfaceHolder mHolder;

    private Camera mCamera;



    public CameraVisualizacao(Context context, Camera camera)

    {

        super(context);

        mCamera = camera;

        mCamera.setDisplayOrientation(90);

        mHolder = getHolder();

        mHolder.addCallback(this);

        mHolder.setType(SurfaceHolder.SURFACE_TYPE_NORMAL);

    }

O método construtor irá receber dois parâmetros, sendo: O Contexto e o objeto Camera. 
Dentro do mesmo iremos setar algumas propriedades como por exemplo a orientação do visor
 (“setDisplayOrientation”).



    @Override

    public void surfaceCreated(SurfaceHolder surfaceHolder)

    {

        try

        {

            mCamera.setPreviewDisplay(surfaceHolder);

            mCamera.startPreview();

        }

        catch (IOException e) {

            Log.d("ERRO", "Problemas para criar o Preview da Câmera!" + 
e.getMessage());

        }

    }



No método sobrescrito “SurfaceCreated” iremos implementar um “try/catch” para definirmos a
superfície a ser utilizada para visualização (setPreviewDisplay) e o início da captura e desenho dos 
enquadramentos para a tela (startPreview).



    @Override

    public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i2, int i3)

    {

        if(mHolder.getSurface() == null) return;



        try

        {

            mCamera.stopPreview();

        } 

        catch (Exception e){

        }

        try

        {

            mCamera.setPreviewDisplay(mHolder);

            mCamera.startPreview();

        } catch (IOException e) {

            Log.d("ERRO", " Problemas para criar o Preview da Câmera!" +

            e.getMessage());

        }

    }

O método “SurfaceChanged” é chamado quando a superfície tem suas características alteradas.

Assim podemos redefinir a superfície a ser utilizada para visualização.



    @Override

    public void surfaceDestroyed(SurfaceHolder surfaceHolder)

    {

        mCamera.stopPreview();

        mCamera.release();

    }

}

Listagem 02.

O método “SurfaceDestroyed” é invocado quando paramos a aplicação. Liberamos todos os objetos da memória.

Implementação da atividade principal “MainActivity”.

Esta Activity irá consumir a classe “Camera” e apresentá-la na tela de nosso aplicativo. Listagem 03.

import android.hardware.Camera;

import android.support.v7.app.AppCompatActivity;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.widget.FrameLayout;

import android.widget.ImageButton;

Deveremos importar algumas bibliotecas para esta tarefa.



public class MainActivity extends AppCompatActivity

{

    private Camera mCamera = null;

    private CameraVisualizacao mCameraView = null;

Para implementar todas as funcionalidades usaremos duas variáveis privadas.



    @Override

    protected void onCreate(Bundle savedInstanceState) 

    {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        try{

            mCamera = Camera.open();

           } catch (Exception e){

            Log.d("ERRO", "Falha ao obter a Câmera: " + e.getMessage());

        }



        if(mCamera != null) {

            mCameraView = new CameraVisualizacao(this, mCamera);

            FrameLayout camera_view = (FrameLayout)findViewById(R.id.camera_view);

            camera_view.addView(mCameraView);

 }



        ImageButton imgClose = (ImageButton)findViewById(R.id.imgClose);

        imgClose.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View view) {

                System.exit(0);

            }

        });

Listagem 03.

Todas as funcionalidades serão inseridas no método “OnCreate”. Através do método “Open” inicializamos a Câmera com o auxílio do “Try/Catch”. Instanciamos a classe “CameraVisualizacao” passando por parâmetro o Contexto e a variável “mCamera”. Por final alimentamos o nosso layout.

Não podemos esquecer da implementação do botão fechar, invocando o método “System.exit”.

Podemos conferir o aplicativo em funcionamento na imagem 04.

Figura 04: Apilcativo em funcionamento.

Conclusões

A ideia principal deste artigo foi apresentar as funcionalidades básicas para a implementação do uso da câmera em aplicativos para o sistema Android. Utilizei bibliotecas específicas, como por exemplo: a “Camera”, a “SurfaceHolder” e a “SurfaceView” e também realizei alterações importantes no arquivo “AndroidManifest”, a fim de chegar em um resultado esperado. Nos próximos artigos irei implementar outras funcionalidades com base no exemplo abordado neste mês.

Um grande abaraço e até o mês que vem.

Asp.Net - Utilizando CAPTCHAs

2019-04-13T12:00:00.002-03:00

Olá amigos, neste mês de Outubro irei explorar um assunto muito comum quando nos deparamos em praticamente qualquer sistema web, o uso dos denominados “CAPTCHAs”. Para quem não sabe e de acordo com inúmeras referências encontradas na internet, o “CAPTCHA” significa um acrônimo da expressão "Completely Automated Public Turing test to tell Computers and Humans Apart" traduzindo significa: “Teste de Turing público completamente automatizado para diferenciação entre computadores e humanos”, simplificando, uma forma de distinguir se uma tarefa está sendo executada por um usuário ou um robô. Veremos neste artigo mais algumas finalidades deste recurso aplicando um exemplo prático utilizando o Microsoft Visual Studio 2015 junto com uma aplicação Asp.Net e a linguagem C#. Utilizarei a biblioteca “Captcha” que poderá ser adquirida e instalada através do “Nuget”.

Finalidade

A finalidade do uso do CAPTCHA são inúmeras, para quem tiver maiores interesses recomendo visitar o link: http://www.captcha.net/, o qual aborda diversas situações deste recurso. O intuito deste artigo seria implementá-lo a fim de proteger o cadastro de um usuário em um site ou sistema web. Um exemplo básico seria a criação de um e-mail na Microsoft. Até poucos anos atrás, a maioria desses serviços sofriam de um tipo específico de ataque: os "bots", os quais se inscreviam para milhares de contas de e-mails a cada minuto. A solução para este problema foi usar CAPTCHAs para garantir que somente os seres humanos pudessem obter estas contas, a fim de evitar abusos por scripts automatizados. Em um sistema web aberto ao público também podemos encontrar problemas como os descritos anteriormente e por sorte podemos diminuir o risco dos mesmos com o uso dos CAPTCHAs.

Baixando e Instalando o “Captcha” através do Nuget

Abra o Miscrosoft Visual Studio 2015 e crie um website do início clicando em “File/New/Website...”. Para fins didáticos iremos criar uma aplicação do tipo Asp.net. Localize o menu “Tools/Nuget Package Manager/Manage Nuget Packages for Solution...”. Pesquise pelo item “Captcha” na caixa de pesquisa, ver Imagem 01.

Figura 01: Biblioteca Captcha.

Após selecionar a biblioteca, localize na região direita a “solution” para instalá-la. Ver Imagem 02.

Figura 02: Instalando o “Captcha”.

Após seguir estas etapas, automaticamente será aberta uma página contendo todas as informações para o uso desta biblioteca em diversas plataformas, inclusive na Asp.Net. Dentro do próprio Visual Studio também será aberto um arquivo “txt” também contendo instruções de implementações. Ver Figura 03.

Figura 03: Instruções de uso.

Criando um exemplo

Seguindo como base as instruções de uso desta biblioteca, adicione no webform o captcha, um textbox e um button. Ver Imagem 04.

Figura 04: Layout proposto.

Abaixo a codificação referente:

<div>

<tr>

<td>

<BotDetect:WebFormsCaptcha ID="ExemploCaptcha" runat="server" Width="290px" />

</td>

</tr>

<tr>

<td>

<asp:TextBox ID="CaptchaCodeTextBox" runat="server" Width="272px" /></td>

</tr>

<tr>

<td>

<asp:Button ID="Button1" runat="server" Text="Testar" Width="205px" OnClick="Button1_Click1" />

</td>

</tr>

</table>

</div>

Listagem 01.

A Tag “BotDetect” fará todo o trabalho do captcha. No próprio componente teremos os caracteres para validação, o botão atualizar e embaralhar letras e outro botão para emitir o som das letras (para deficientes visuais).

Usaremos uma quantidade mínima de linhas, no evento “Click” do botão “testar” teremos a seguinte codificação. Listagem 02.

protected void Button1_Click1(object sender, EventArgs e)

{

bool validar = ExemploCaptcha.Validate(CaptchaCodeTextBox.Text);

CaptchaCodeTextBox.Text = null;

if (!validar)

{

Response.Write("Erro na validação!");

}

else

{

Response.Write("Validação correta!");

}

Listagem 02.

Criaremos uma variável booleana que servirá para validar o texto digitado. Implementaremos o método “Validate” do componente “ExemploCaptcha” o qual nos retornará “verdadeiro” ou “falso”. Uma ideia para retornar o resultado seria pelo método “Response.Write” através de uma condição. Ver Figura 05.

Figura 05: Resultado final.

Conclusões

O recurso apresentado neste artigo é utilizado em quase na totalidade de sites que existem a necessidade da utilização de um cadastro por exemplo. É comum também encontrarmos sistemas web que faz o uso deste mecanismo. O “Captcha” foi inventado com o intuito de diminuir o ataque de robôs, scripts maliciosos, entre outros. Existem inúmeras bibliotecas no Visual Studio para esta tarefa, procurei explorar a “Capctha”, sendo de fácil aquisição, instalação e utilização.

Desejo a todos uma ótima leitura. Abraços

Referências

http://www.captcha.net/

https://pt.wikipedia.org/wiki/CAPTCHA

Microsoft Visual Studio - Como utilizar o Nuget

2019-04-13T11:56:00.001-03:00

Olá amigos, no artigo deste mês irei apresentar um mecanismo muito util na plataforma .NET através do Microsoft Visual Studio, o gerenciador de bibliotecas Nuget. O principal objetivo do Nuget é garantir que todas as dlls estejam atualizadas com suas últimas versões, evitando erros de referências nos projetos. Podemos destacar outras características deste utilitário como: a facilidade para remoção de bibliotecas externas, criação do próprio pacote (package) e consequentemente torná-lo disponível para terceiros.

É importante destacar que este recurso está disponível a partir do Microsoft Visual Studio 2012. (Para quem possuir a versão 2010 e desejar instalá-lo, com o Visual Studio aberto localize o item ”Extension Manager” no menu “Ferramentas” procurando “Nuget Package Manager” na guia “Galeria Online”.)

Utilizando o Nuget

Depois de abrir o Microsoft Visual Studio, crie um projeto de exemplo para aprendermos a trabalhar com o Nuget, no meu caso foi criada uma “solution” do tipo “Windows Forms” denominada “WindowsFormsApplicationNuget”. Para adicionar um pacote podemos clicar com o botão direito no item “References” escolhendo a Opção “Manage NuGet Package” (Figura 01) ou no Menu “Tools/ Nuget Package Manager/ Manage Nuget Package Manager for Solution” (Figura 02)

Figura 01: Manage Nuget Packages.

Figura 02: Tools/Manage Nuget Packages.

Na próxima tela iremos nos deparar com diversas informações e opções. Na região superior direita teremos com uma caixa de diálogo para realizar a pesquisa da biblioteca. Podemos também ordenar o resultado desta pesquisa por relevância, data ou descrição.

Ao selecionar o pacote desejado, será demostrada informações como: Criado por , Id , Versão , Downloads, Descrição, Dependências , entre outras coisas. Ver Figura 03.

Figura 03: Localizando o Package.

Para fins de exemplo, escolhi a biblioteca “Microsoft.Office.Interop.Excel” para trabalhar com planilhas eletrônicas. Clicando no botão “Install“ iremos baixar a biblioteca junto com suas dependências e logo em seguida instalá-la em nossa aplicação. (Figura 04)

Uma vez instalada , ela faz algumas mudanças em seu projeto como se você estiver adicionando um pacote pela primeira vez , em seguida, ele irá criar um arquivo chamado “packages.config” .

Importante: Este arquivo mantém uma lista de todos os pacotes que estão instalados no seu projeto. Ver Figura 04.

Figura 04: Arquivo Packages.config.

Outra tarefa realizada automaticamente seria a criação uma pasta chamada “packages” no diretório onde o arquivo de solução ( .sln ) reside. Esta pasta contém uma subpasta para cada pacote instalado com o número da versão. Veja Imagem 05.

Figura 05: Pasta Packages.

O arquivo “repositories.config” contém o caminho para o “packages.config”.

Utilizamos a mesma tela mencionada anteriormente na Figura 03 para remoção e atualização do package na aplicação. Por exemplo: Para remover o pacote “Microsoft.Office.Interop.Excel”, na região esquerda, clique em “Installed Packages” e localize o mesmo finalizando com o botão “Uninstall”. Já para verificar se o mesmo possui atualizações clique na região “Updates”. Ver Figura 06.

Figura 06: Removendo e Atualizando Pacotes.

Utilizando o Nuget por linha de comando

Podemos utilizar o Nuget por linha de comando clicando no menu “Tools/Nuget Package Manager/Package Manager Console”. Ver Imagem 07.

Figura 07: Package Manager Console.

Instalando um pacote:

Install-Package Microsoft.Office.Interop.Excel

Atualizando um pacote:

Update-Package Microsoft.Office.Interop.Excel

Removendo um pacote:

Uninstall-Package Microsoft.Office.Interop.Excel

Podemos conferir todos os comandos comentados acima na Figura 08.

Figura 08: Package Manager Console.

Conclusões

Neste artigo procurei explorar este importante recurso presente no Microsoft Visual Studio, o gerenciador de bibliotecas Nuget. Com poucos cliques temos a facilidade da instalação, atualização e remoção de qualquer biblioteca presente na plataforma .Net. Uma outra opção também abordada seria realizar estas mesmas tarefas via linha de comando.

Fica aí a dica pessoal, um abraço e até o mês que vem!

Windows Forms - Trabalhando com arquivos do Excel

2019-04-13T11:50:00.000-03:00

No artigo deste mês irei abordar um assunto muito comum no nosso suporte técnico, o uso de arquivos do Microsoft Excel junto com Windows Forms. Demonstrarei como devemos realizar a integração da biblioteca “System.Data.OleDb”, presente na plataforma .NET e responsável pela implementação de rotinas de inserção e atualização de dados em arquivos do tipo “xls” ou “xlsx”, tendo como base a linguagem C#.

Importante: Para este exemplo terei como base o uso do Microsoft Excel 2013

Conhecendo o Namespace “System.data.OleDb”

Este “Namespace” representa uma coleção de classes usadas para acessar uma fonte de dados do tipo OLE DB, ou seja, a mesma possui métodos específicos que irão nos auxiliar e facilitar o uso de nossa fonte de dados específica (arquivos “xls” ou “xlsx”).

Iremos descrever as principais classes e métodos presentes neste Namespace, sendo:

Classe OleDbConnection: Representa uma conexão com uma fonte de dados. O método “Open()” é reponsável por abrir uma conexão de banco de dados com as configurações de propriedades especificadas pela string de conexão. Já o “Close()” finaliza a conexão com a fonte de dados.

Classe OleDbCommand: Representa uma instrução SQL ou procedimento armazenado a executar em uma fonte de dados. Possuímos o método “Parameters.AddWithValue()”, o qual receberá os parâmetros indicados em uma instrução SQL.

Exemplo: Parameters.AddWithValue(“@descricao”, “the club”)

Sendo:“@descricao” significa o nome e “the club” o valor do parâmetro.

Para executar a instrução SQL e retornar um número de linhas afetadas podemos utilizar o método “ExecuteNonquery()”.

Criando o Exemplo

Antes de partirmos para a implementação do nosso exemplo, será necessário criar um pequeno arquivo “XLSX” contendo: Id, Nome, Contato e Documento. Ver Figura 01.

Figura 01: Estrutura do Arquivo XLSX.

Com o Microsoft Visual Studio iniciado crie uma solução do tipo “Windows Forms” contendo um formulário com os mesmos tipos de campos descritos anteriormente. Aproveite também para adicionar um botão para Inserir dados e outro para atualizá-los. Através da Figura 02 podemos ter uma noção de como deverá ficar esta tela.

Figura 02: Formulário de Exemplo.

Codificando o Exemplo

Usaremos os seguintes Namespaces:

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using System.Data.OleDb;

using System.IO;

Para organizarmos nosso código achei de extrema importância criar alguns métodos específicos, sendo: o “LimparDados()” como o próprio nome já diz, será responsável por limpar os dados contidos em todos os “TextBoxes” (Listagem 01) após a inserção ou atualização e o “ConexaoXlsx()”, contendo a String de conexão junto com o caminho do arquivo “xlsx”. (Listagem 02)

private void LimparDados()

{

txtId.Clear();

txtNome.Clear();

txtDocumento.Clear();

txtContato.Clear();

}

Listagem 01.

Para obtermos o caminho do “.exe” automaticamente usaremos o método “Path.GetDirectoryName” passando “Application.ExecutanlePath” como parâmetro. Após esta etapa concatenaremos com o nome do arquivo do tipo “xlsx” (exemplo.xlsx). A String de conexão é específica para arquivos desde a versão 2010 do Microsoft Excel, ou seja, será obrigatório incluir o “Provider”, o “Data Source” e o “Extended Properties”, conforme indicado no código abaixo.

private string ConexaoXlsx()

{

string Caminho = Path.GetDirectoryName(Application.ExecutablePath);

string ArquivoXlsx = Caminho + "\\exemplo.xlsx";

return "Provider=Microsoft.ACE.OLEDB.12.0;Data Source='" + ArquivoXlsx + "';Extended Properties=Excel 12.0;";

}
Listagem 02.

No evento “Click” do botão inserir instanciaremos a classe “OleDbConnection” passando no construtor o procedimento “ConexaoXlsx”. Criaremos uma variável do tipo texto para nossa instrução de “INSERT”.
Usaremos o nome contido na aba do Excel (Exemplo: [Folha1$] ), seguido de “$”. Para a criação dos comandos instanciaremos a classe “OleDbCommand” usando as variáveis “Sql” e “Conexao”. Logo em seguida adicionaremos os parâmetros (id, nome, contato, documento) através do método “Parameters.AddWithValue”, abriremos a conexão através do método “Open()” e por final com o auxílio de um bloco “try/catch” executamos o “Insert”. Ver Listagem 03.

private void btnInserir_Click(object sender, EventArgs e)

{

using (OleDbConnection Conexao = new OleDbConnection(ConexaoXlsx()))

{

string Sql = "INSERT INTO [Folha1$] (id, nome, contato, documento) VALUES (@id, @nome, @contato, @documento)";

OleDbCommand Comandos = new OleDbCommand(Sql, Conexao);

Comandos.Parameters.AddWithValue("@id", txtId.Text);

Comandos.Parameters.AddWithValue("@nome", txtNome.Text);

Comandos.Parameters.AddWithValue("@contato", txtContato.Text);

Comandos.Parameters.AddWithValue("@documento", txtDocumento.Text);

Conexao.Open();

try

{

Comandos.ExecuteNonQuery();

MessageBox.Show("Dados Inseridos com Sucesso!");

LimparDados();

}

catch

{

MessageBox.Show("Ocorreu um erro ao Inserir os Dados!");

}

Conexao.Close();

}

Listagem 03.

O botão “Atualizar Dados” irá executar uma instrução de “UPDATE” no arquivo “xlsx”. Teremos o código idêntico ao que foi explicado anteriormente. Ver Listagem 04.

private void btnAtualizar_Click(object sender, EventArgs e)

{

using (OleDbConnection Conexao = new OleDbConnection(ConexaoXlsx()))

{

string strSQL = "UPDATE [Folha1$] SET nome = @nome, contato = @contato, documento = @documento WHERE id = '"+txtId.Text+"'";

OleDbCommand Comandos = new OleDbCommand(strSQL, Conexao);

Comandos.Parameters.AddWithValue("@nome", txtNome.Text);

Comandos.Parameters.AddWithValue("@contato", txtContato.Text);

Comandos.Parameters.AddWithValue("@documento", txtDocumento.Text);

Conexao.Open();

try

{

Comandos.ExecuteNonQuery();

MessageBox.Show("Dados Atualizados com Sucesso!");

LimparDados();

}

catch

{

MessageBox.Show("Ocorreu um erro ao Atualizar os Dados!");

}

Conexao.Close();

}

Listagem 04.

Ao compilar e executar a aplicação teremos um resultado parecido com o da Figura 03.

Figura 03: Exemplo de Inserção.

O mesmo resultado poderá ser conferido utilizando o botão “Atualizar Dados”.

Ao realizar algumas inserções ou atualizações, teremos uma planilha alimentada com alguns registros. Ver Imagem 04.

Figura 04: Exemplo.

Conclusões

Procurei neste artigo explorar algumas funcionalidades da biblioteca “System.Data.OleDb” presente na plataforma .NET. Uma das características destra biblioteca seria a integração com planilhas do Microsoft Excel, o qual foi abordado minuciosamente neste mês com um exemplo prático.

Desejo a todos uma ótima leitura, um abraço e até o mês que vem!

Referências

https://msdn.microsoft.com/pt-br/library/system.data.oledb(v=vs.110).aspx

https://msdn.microsoft.com/pt-br/library/system.data.oledb.oledbconnection(v=vs.110).aspx

Asp.Net - Desenvolvendo um teclado numérico randômico – Parte 2

2019-04-13T11:46:00.001-03:00

Olá amigos, neste mês irei dar continuidade ao artigo iniciado no mês anterior. Demonstrarei toda a codificação necessária para obtermos a funcionalidade proposta. Lembramos que estamos utilizando o Microsoft Visual Studio, junto com a linguagem C#. Desenvolveremos alguns métodos, como por exemplo: o “EmbaralhaLista ()”, responsável por embaralhar os números do teclado numérico, o “CarregaNumeros ()”, o qual irá alimentar os textos dos botões em diversos momentos, entre outros.

Codificando o Exemplo

Inicialmente deveremos declarar alguns namespaces, sendo:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Collections;

O uso do Namespace “System.Collections” foi necessário para utilizar principalmente a classe “List”.

A rotina “EmbaralhaLista” recebe como parâmetro um dado do tipo “List” com uma determinada lista numérica. Irá nos retornar uma “List” com uma numeração embaralhada. Para isto criamos uma varável “randomList”, uma do tipo “Random” e um inteiro chamado “randomIndex”. Dentro de um laço de repetição “While” iremos varrer todos os itens recebidos como parâmetro de entrada e contidos na variável “inputList” atribuindo o índice randômico e logo em seguida adicionando na lista randômica. O resultado será uma lista de 10 números sortidos. Ver Listagem 01.

public List<E> EmbaralharLista<E>(List<E> inputList)

{

List<E> randomList = new List<E>();

Random r = new Random();

int randomIndex = 0;

while (inputList.Count > 0)

{

randomIndex = r.Next(0, inputList.Count);

randomList.Add(inputList[randomIndex]);

inputList.RemoveAt(randomIndex);

}

return randomList;

}

Listagem 01.

O método “CarregarNumeros()” irá atribuir valores numéricos à propriedade “Text” dos cinco botões do teclado, sendo:

Botão 01	0 - 1
Botão 02	2 – 3
Botão 03	4 – 5
Botão 04	6 – 7
Botão 05	8 – 9

O primeiro passo seria criar uma variável do tipo “List” contendo valores inteiros. Adicione o intervalo de 0 a 9 nesta variável, com o auxílio da estrutura de repetição “For”. Neste momento iremos fazer o uso da função “EmbaralhaLista” descrita anteriormente, declarando mais uma variável do tipo List<int> e invocando o método “EmbaralhaLista”. Montaremos a propriedade “Text” dos botões com dois números aleatórios separados um traço “ – “. Ver Listagem 02.

public void CarregarNumeros()

{

List<int> numeros = new List<int>();

for (int i = 0; i <= 9; i++)

{

numeros.Add(i);

}

List<int> numeros_randomicos = new List<int>();

numeros_randomicos = EmbaralharLista(numeros);

btn01.Text = numeros_randomicos[0].ToString() + " - " + numeros_randomicos[1].ToString();

btn02.Text = numeros_randomicos[2].ToString() + " - " + numeros_randomicos[3].ToString();

btn03.Text = numeros_randomicos[4].ToString() + " - " + numeros_randomicos[5].ToString();

btn04.Text = numeros_randomicos[6].ToString() + " - " + numeros_randomicos[7].ToString();

btn05.Text = numeros_randomicos[8].ToString() + " - " + numeros_randomicos[9].ToString();

}
Listagem 02.

Não podemos esquecer de implementar a função “CarregarNumeros” no método “Load” da página. Listagem 03.

protected void Page_Load(object sender, EventArgs e)

{

if (!IsPostBack)

{

CarregarNumeros();

}

Listagem 03.

A implementação da função “RecebeValores” foi de extrema importância para armazenarmos apenas os valores numéricos dos botões, ou seja, teremos como valores de entrada o texto puro da propriedade “Text” do botão e o retorno numérico. Ver listagem 04.

public string RecebeValores(string btn)

{

return btn.Substring(0, 1) + btn.Substring(4, 1);

}
Listagem 04.

Teremos a mesma codificação no evento “Click” dos cinco botões. Iremos testar o campo TextBox txtSenha verificando se a mesma possui um tamanho menor que 6 e logo em seguida atribuímos o valor “#”, assim conseguimos identificar que foi digitado algum valor. Usaremos uma “Session” para armazenar nossos valores. Ver Listagem 05 abaixo.

protected void btn01_Click(object sender, EventArgs e)

{

if (txtSenha.Text.Length < 6)

{

txtSenha.Text += "#";

Session["senha"] += RecebeValores(btn01.Text)+",";

}

protected void btn02_Click(object sender, EventArgs e)

{

if (txtSenha.Text.Length < 6)

{

txtSenha.Text += "#";

Session["senha"] += RecebeValores(btn02.Text)+",";

}

protected void btn03_Click(object sender, EventArgs e)

{

if (txtSenha.Text.Length < 6)

{

txtSenha.Text += "#";

Session["senha"] += RecebeValores(btn03.Text)+",";

}

protected void btn04_Click(object sender, EventArgs e)

{

if (txtSenha.Text.Length < 6)

{

txtSenha.Text += "#";

Session["senha"] += RecebeValores(btn04.Text)+",";

}

protected void btn05_Click(object sender, EventArgs e)

{

if (txtSenha.Text.Length < 6)

{

txtSenha.Text += "#";

Session["senha"] += RecebeValores(btn05.Text)+",";

}

}
Listagem 05.

No evento Click do botão “Ok” faremos o trabalho de comparar a senha digitada com a senha contida em uma tabela de um banco de dados por exemplo. No nosso caso específico iremos criar uma senha a partir de uma variável do tipo “String”, contendo qualquer valor numérico aleatório com seis caracteres.

Exemplo: string senha_banco = “855971”.

Faremos a comparação da senha e do cpf digitado. Trataremos a variável “senhadigitada” armazenando cada caracatere em uma variável alfanumérica. A minha sugestão de lógica seria ir comparando caractere por caractere através de uma combinação de “Ifs” com o auxílio da função “Substring”. Confiram maiores detalhes na Listagem 06.

protected void btnOk_Click(object sender, EventArgs e)

{

string senha_banco = "855971";

string cpf_banco = "31222288860";

if (cpf_banco == txtCpf.Text)

{

string senha_digitada = Session["senha"].ToString();

if (senha_digitada.Length == 18)

{

string[] senha_digitada_char = senha_digitada.Split(',');

string str0 = senha_digitada_char[0];

string str1 = senha_digitada_char[1];

string str2 = senha_digitada_char[2];

string str3 = senha_digitada_char[3];

string str4 = senha_digitada_char[4];

string str5 = senha_digitada_char[5];

if ((str0.Substring(0, 1) == senha_banco.Substring(0, 1)) || (str0.Substring(1, 1) == senha_banco.Substring(0, 1)))

{

if ((str1.Substring(0, 1) == senha_banco.Substring(1, 1)) || (str1.Substring(1, 1) == senha_banco.Substring(1, 1)))

{

if ((str2.Substring(0, 1) == senha_banco.Substring(2, 1)) || (str2.Substring(1, 1) == senha_banco.Substring(2, 1)))

{

if ((str3.Substring(0, 1) == senha_banco.Substring(3, 1)) || (str3.Substring(1, 1) == senha_banco.Substring(3, 1)))

{

if ((str4.Substring(0, 1) == senha_banco.Substring(4, 1)) || (str4.Substring(1, 1) == senha_banco.Substring(4, 1)))

{

if ((str5.Substring(0, 1) == senha_banco.Substring(5, 1)) || (str5.Substring(1, 1) == senha_banco.Substring(5, 1)))

{ Response.Write("Autenticação Realizada com Sucesso!");

}

Listagem 06.

No evento “Click” do botão “limpar” removeremos todos os dados contidos na sessão, e por consequência limparemos o componenete “txtsenha”. Ver código abaixo na Listagem 07.

protected void btnLimpar_Click(object sender, EventArgs e)

{

txtSenha.Text = "";

Session.Contents.Remove("senha");

}

Listagem 07.

Teremos um resultado idêntico ao da Figura 01.

Figura 01: Resultado Final.

Conclusões

Nesta segunda e última parte procurei explorar todo o código necessário, contendo todas as explanações e comentários referentes a este tipo de funcionalidade utilizando páginas Web Asp.Net.

Espero ter ajudado, fica aí a dica galera.

Asp.Net - Desenvolvendo um teclado numérico randômico – Parte 1

2019-04-11T17:40:00.003-03:00

Este mês irei explorar um assunto que com certeza irá ser útil para programadores que necessitam incorporar autenticação via teclado numérico em seus sistemas. Para isto, desenvolverei um teclado numérico randômico, idêntico ao que possuímos em sites de bancos, portais específicos, ou seja, para tipos de aplicações que exigem um grau maior de segurança. Na primeira parte deste artigo explorarei apenas a interface gráfica, com todos os detalhes necessários. O exemplo será desenvolvido utilizando a tecnologia Asp.Net com a linguagem C# utilizando como ferramenta de desenvolvimento o Microsoft Visual Studio. Para realçar o visual do mesmo implementarei algumas classes do bootstrap em conjunto com o JQuery.

Bootstrap e JQuery

Não explorarei detalhes na instalação e configuração destas tecnologias, pois são assuntos que já foram citados em nossa revista. Para isto irei recomendar a leitura de dois artigos, sendo o primeiro denominado “Bootstrap - Pontapé inicial na utilização do Framework pelo Visual Studio” podendo ser encontrado no mês de Fevereiro de 2015 e ser acessado pelo link:

http://www.theclub.com.br/Restrito/Revistas/201502/boot1502.aspx

O segundo sobre JQuery entitulado como “Asp.Net – Trabalhando com JQuery 2.x” do mês de Julho de 2015, encontrado no link:

http://www.theclub.com.br/Restrito/Revistas/201507/aspn1507.aspx

(Importante lembrar que apesar deste último artigo estar explorando uma versão superior do JQuery, podemos facilmente seguir os mesmos passos descritos no artigo trocando pela versão 1.x.)

Após baixar estes arquivos, deveremos possuir uma pasta chamada “bootstrap” com o conteúdo idêntico ao da Figura 01.

Figura 01: Pasta Bootstrap.

E dentro da pasta “js” obrigatoriamente os arquivos de scripts necessários para o bom funcionamento do exemplo.

Ver Imagem 02.

Figura 02: Pasta “js”.

Criando o exemplo

Abra o Visual Studio e crie uma solução do tipo “Web Site ... “ com o nome que desejar. Esta Solution deverá conter por padrão o arquivo “Web.config”, um WebForm (onde irá conter o nosso teclado) e a pasta Bootstrap supracitada. Ver Imagem 03.

Figura 03: Solution.

Sugiro renomear o arquivo “aspx” para “FrmTeclado” e primeiramente adicionar o componente “ScriptManager” situado na Toolbox “AJAX Extensions”, componente de uso obrigatório e responsável por habilitar as funcionalidades do AJAX na página. Deveremos adicionar uma “Table” e dentro da mesma os botões numéricos, Limpar e OK, os TextBoxes CPF e Senha. O Layout deverá ficar idêntico ao da figura 04.

Figura 04: Layout proposto.

Abaixo a codificação comentada:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="FrmTeclado.aspx.cs" Inherits="FrmTeclado" %>

<!DOCTYPE html>

</head>

Dentro da TAG Head deveremos adicionar o código necessário para o funcionamento das funções BootStrap.

<body>

<div>

<asp:ScriptManager ID="ScriptManager1" runat="server">

</asp:ScriptManager>
</div>

Deveremos adicionar na TAG Body os dois arquivos de scripts: JQuery e Bootstrap. Preferencialmente o componente “Scriptmanager” deverá estar contido dentro de uma DIV, conforme código acima.

<div>

<tr>

<asp:Button Class="btn btn-navbar" ID="btn01" runat="server" Text="0 - 1" OnClick="btn01_Click" Font-Bold="False" Font-Size="Medium" Height="30px" />

</td>

<asp:Button Class="btn" ID="btn02" runat="server" Text="2 - 3" OnClick="btn02_Click" Font-Size="Medium" Height="30px" />

</td>

</tr>

<tr>

<asp:Button Class="btn" ID="btn03" runat="server" Text="4 - 5" OnClick="btn03_Click" Font-Size="Medium" Height="30px" /></td>

<asp:Button Class="btn" ID="btn04" runat="server" Text="6 - 7" OnClick="btn04_Click" Font-Size="Medium" Height="30px" />

</td>

</tr>

<tr>

<asp:Button Class="btn" ID="btn05" runat="server" Text="8 - 9" OnClick="btn05_Click" Font-Size="Medium" Height="30px" />

</td>

<asp:Button Class="btn btn-danger" ID="btnLimpar" runat="server" Text="Limpar" OnClick="btnLimpar_Click" Height="30px" />

</td>

</tr>

</table>

</div>

</td>

A minha sugestão seria trabalhar com o conjunto de componentes, Div, Table e dentro das colunas deveremos adicionar os botões numéricos (0 ao 9) e o Limpar. Utilizei algumas classes do bootstrap para enfeitar os botões do teclado, como por exemplo a “btn”, “btn btn-danger”. Na “Table” principal utilizamos a classe “well” para um fundo bonito.

</tr>

<tr>

<td>

<asp:TextBox ID="txtCpf" runat="server"Width="200px"></asp:TextBox>

</td>

</tr>

</table>

</td>

</tr>

<tr>

<tr>

<td align="right" width="25%">SENHA: </td>

<asp:UpdatePanel ID="UpdatePanel1" runat="server">

<asp:TextBox ID="txtSenha" runat="server" MaxLength="6" BackColor="White" ReadOnly="True" Width="200px"></asp:TextBox>

</ContentTemplate>

</asp:UpdatePanel>

</td>

</tr>

</table>

</td>

</tr>

A autenticação será realizada pelo campo CPF e por um campo Senha. Nesta região faremos o uso de outra “table”. Importante ressaltar o componente “UpdatePanel”, utilizado para renderizar partes parciais de uma tela sem a necessidade de fazer um completo PostBack. Este comportamento será necessário para adicionar os valores numéricos randômicos ao textbox.

<asp:Button Class="btn btn-primary" ID="btnOk" runat="server" style="text-align: center" Text="Ok" Width="109px" OnClick="btnOk_Click" />

</td>

</tr>

</table>

</div>

</form>

</body>

</html>

Para finalizar teremos um botão “Ok”, o qual irá disparar o evento “btnOk_Click”, o qual fará o trabalho de comparar os valores escolhidos no teclado.

Ao executar nosso exemplo teremos uma aparência idêntica ao da Figura 05.

Figura 05: Executando o exemplo.

Conclusões

A primeira parte deste artigo explorei todos os detalhes necessários para criar uma interface de teclado numérico randômico. Utilizei algumas classes do Bootstrap junto com comandos básicos HTML quando trabalhamos com Web Forms. No mês que vem irei finalizá-lo com toda a codificação necessária para o funcionamento do exemplo proposto.

Um grande abraço

Asp.Net - Consumindo serviços REST com a biblioteca RestSharp

2019-04-11T17:37:00.002-03:00

Este mês irei explicar como devemos consumir serviços REST em Asp.Net com o auxílio da biblioteca RestSharp. O modelo REST (Representational State Transfer) tem sido cada vez mais utilizado na implementação de serviços em diversas plataformas. Para entender um pouco mais sobre a tecnologia REST, recomendo a leitura do artigo “AngularJS – Consumindo serviços REST” publicado no mês de Maio de 2016, o qual aborda diversos conceitos sobre este formato de transmissão de dados. Focarei esta dica em um exemplo prático com base nas consultas propostas no artigo supracitado.

Biblioteca RestSharp

RestSharp é uma biblioteca cliente “http” poderosa que irá trabalhar com qualquer tipo de

tecnologia .Net. (No nosso caso Asp.Net com a linguagem C#) Esta biblioteca inclui o denominado

“inbuild” “desserializadores” para suportar o formato XML e JSON. Com base no tipo de conteúdo

devolvido pelo servidor, a RestSharp define o “desserializador” adequado. Segue abaixo os tipos de

conteúdo suportados:

- Application/Json (JsonDeserialize),

- Application/Xml (XmlDeserialize),

- Text/Json (JsonDeserialize),

- Text/Xml (XmlDeserialize).

Importante salienar que usaremos o padrão JSON.

Instalando a RestSharp 

Com o Visual Studio aberto inicie um projeto do início do tipo “Asp.Net” clicando em

“File/New/Web Site...”. Usaremos a ferramenta “Nuget Package Manager”, para isto clique em

“Tools/Nuget Package Manager” escolhendo a opção “Manage Nuget Packages For Solution ...”

Ver Imagem 01.

Figura 01: Manage Nuget Packages for Solution.

Com o “Nuget” podemos instalar facilmente bibliotecas em qualquer tipo de solução .Net. Ao abrir a tela pesquise pelo nome “RestSharp” no campo de pesquisa localizado na região supeior direita, conforme Imagem 02.

Figura 02: RestSharp.

Ao escolher o item “RestSharp” Clique no botão “Install” e logo em seguida adicione os pacotes no projeto. O processo pode demorar alguns minutos, pois o mesmo irá realizar o download automaticamente. No término do processo será criada uma pasta chamada “Bin” com todas as dlls utiliadas, sendo: “RestSharp.dll”, “RestSharp.Portable.Core.dll” e “RestSharp.Portable.HttpClient.dll”. Ver Imagem 03.

Figura 03: Pasta Bin.

Criando o Exemplo

Nosso exemplo irá consumir um serviço REST do site http://jsonplaceholder.typicode.com e retornará alguns dados como Nome, E-mail, Site e Id. Faremos a consulta através do “ID”.

Adicione um Web Form no projeto clicando com o botão direito sobre o mesmo escolhendo “Add/Add New Item.../Web Form”. No meu caso defini como “FrmRest.aspx”. Insira na tela alguns componentes como: uma Table com cinco linhas e dentro da mesma 1 Button e 4 Labels (Nome, E-mail, Site, Id). Ver Figura 04.

Figura 04: Lay-Out proposto.

O código para esta tela é bem simples e pode ser conferido na listagem 01.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="FrmRest.aspx.cs" Inherits="FrmRest" %>

<!DOCTYPE html>

<title>Asp.Net - Consumindo serviços REST com a biblioteca RestSharp</title>

</head>

<body>

<strong style="text-align: left">Asp.Net - Consumindo serviços REST com a biblioteca RestSharp</strong></div>

<table>

<tr>

<td>

<asp:Button ID="btnExecutar" runat="server" OnClick="Button1_Click" Text="Executar" style="text-align: center" Width="153px" />

</td>

</tr>

<tr>

<td>

<asp:Label ID="lblNome" runat="server" Text="Nome: " Font-Bold="True" Font-Size="Large"></asp:Label></td>

</tr>

<tr>

<td>

<asp:Label ID="lblEmail" runat="server" Text="E-mail:" Font-Bold="True" Font-Size="Large"></asp:Label>

</td>

</tr>

<tr>

<td>

<asp:Label ID="lblSite" runat="server" Text="Site:" Font-Bold="True" Font-Size="Large"></asp:Label></td>

</tr>

<tr>

<td>

<asp:Label ID="lblId" runat="server" Text="Id:" Font-Bold="True" Font-Size="Large"></asp:Label></td>

</tr>

</table>

<br />

</form>

</body>

</html>

Listagem 01.

No código fonte o primeiro passo seria adicionar a biblioteca RestSharp com o auxílio da cláusula “using”.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.UI;

using System.Web.UI.WebControls;

using RestSharp;

Para consumir os dados é necessário criar uma classe com todos os atributos exatamente iguais aos do objeto JSON. Para isto criamos uma classe chamada “Usuario” com os atributos “Name”, “Email”, “WebSite” e “Id”.

public class Usuario

{

public string Name

{

get;

set;

}

public string Email

{

get;

set;

}

public string Website

{

get;

set;

}

public string Id

{

get;

set;

}

No evento “Click” do botão iremos realizar todo o processo responsável por consumir e nos retornar os dados.

protected void Button1_Click(object sender, EventArgs e)

{

var client = new RestClient("http://jsonplaceholder.typicode.com/users/");

var request = new RestRequest("3", Method.GET);

var response = client.Execute<Usuario>(request);

Usuario usuario = response.Data;

lblNome.Text = string.Format("Nome: {0}", usuario.Name);

lblEmail.Text = string.Format("E-mail: {0}", usuario.Email);

lblSite.Text = string.Format("Site: {0}", usuario.Website);

lblId.Text = string.Format("Id: {0}", usuario.Id);

}

Deveremos instanciar o objeto “RestClient” passando no construtor o endereço onde está localizado o serviço REST. O objeto “RestRequest” irá realizar o “pedido” dos dados pelo parâmetro utilizando o método “Method.Get”, ou seja, passaremos o valor inteiro “3”. Através do método “Execute”, presente no objeto “client” teremos um retorno dos dados exatamente no formato da classe “Usuario” criada anteriormente. O método “response.Data” irá alimentar com os registros a classe Usuario. Para atribuir o resultado aos Labels, basta lermos os atributos da classe através do “Get”. Ao clicar no botão “Executar” teremos um resultado idêntico ao da Figura 05.

Figura 05: Consumindo dados.

Conclusões

Trabalhamos neste artigo com a biblioteca “RestSharp”, um pacote open-source disponível para a plataforma .Net. Vimos também que com uma quantidade mínima de código pudemos consumir facilmente um serviço REST.

Vou ficando por aqui desejando um grande abraço e até o mês que vem.

Referências

http://restsharp.org/

Instalando o Microsoft SQL Server 2016 Release Candidate 3

2019-04-11T11:57:00.003-03:00

No mês passado, foi abordada algumas funcionalidades do pré-lançamento deste Banco de dados com o artigo “Principais recursos do Microsoft SQL Server 2016”. Para este mês, irei demonstrar como adquirir e instalar esta primeira demonstração pública desta nova versão do banco de dados da Microsoft.

Pré-requisitos

Alguns pré-requisitos serão necessários para a instalação, sendo:

-Sistema de Arquivo: é recomendável executar o SQL Server 2016 em computadores com o formato de arquivo NTFS.
- Sistemas Operacionais suportados: Windows Server 2012, Windows 10, Windows 8.1, Windows 8.
- Todos os sistemas operacionais estão disponíveis apenas como de 64 bits, ou seja, o SQL Server deverá ser instalado apenas em sistemas operacionais 64 bits.
- Mínimo de 512 MB para a edição “Express” e mínimo de 1GB para as outras.
- Processador no mínimo 1,4 GHz e recomendado 2.0 GHz.
- 8 GB de espaço disponível em disco rígido.

Realizando o Download

Para efetuar o download deveremos seguir alguns passos acessando o site:

https://www.microsoft.com/pt-br/evalcenter/evaluate-sql-server-2016?lc=1046

A primeira etapa seria clicar no item “Baixar” e logo em seguida no botão “Entrar” (É necessário possuir uma conta na Microsoft). Ver Imagem 01.

Figura 01: Efetuando a primeira etapa.

Já no próximo passo escolheremos o tipo de arquivo para ser baixando, tendo como opções: ISO, CAB e AZURE. Para o nosso exemplo, iremos escolher o “ISO” para termos uma imagem para ser emulada ou gravada em um DVD. Clique no botão “Registre para Continuar”. Ver Imagem 02.

Figura 02: Escolhendo o tipo de arquivo.

A última etapa seria preencher um formulário de cadastro com algumas informações para finalmente iniciarmos o Download. O arquivo possui o tamanho de aproximadamente 2.3 GB.

Realizando a Instalação

A instalação é muito simples e intuitiva. Ela segue os mesmos conceitos das versões anteriores, por isto comentarei apenas algumas das principais etapas.

Execute o arquivo “SQLServer2016RC3-x64-CHT” e teremos uma tela conforme indica a Figura 03.

Figura 03: Instalação.

Na etapa “Planejamento” teremos algumas informações como: Requisitos de Hardware e Software, Documentação, Notas da versão entre outros dados. Clique na região “Instalação” para iniciarmos o processo. Ver Imagem 04.

Figura 04: Instalação Autônoma.

Ao clicar em “Nova instalação autônoma do SQL Server ...” iniciaremos um assistente para a instalação do banco de dados em um ambiente não clusterizado.

Na tela a seguir temos a possibilidade de especificar a edição do SQL Server 2016 RC3 a ser instalada. Podemos inserir a chave de 25 caracteres do certificado de autenticidade da Microsoft ou alguma edição gratuita como: Developer, Evaluation ou Express. Especificaremos a “Express” e logo em seguida clicaremos no botão “Avançar” para logo em seguida aceitar os termos de licença do produto.

Na Figura 05 podemos conferir as regras globais de instalação, as quais identificam problemas que poderão ocorrer quando instalamos arquivos de base.

Importante: Todas as regras deverão estar com o Status “Aprovado”, conforme indica a imagem supracitada.

Figura 05: Regras Globais.

Temos a opção de atualização do Sistema Operacional e do Produto para a instalação dos arquivos e das regras. As próximas telas darão ênfase para estas operações. Não teremos muito o que se preocupar, basta escolhermos o botão “Avançar”. A Figura 06 engloba todas estas etapas.

Figura 06:Atualizando e instalando Arquivos.

Na opção “Seleção de Recursos” selecionaremos todos os recursos presentes e aproveitaremos para deixar o “Diretório raiz da instância”, “Diretório de recursos compartilhados” e “Diretório de recursos compartilhados (x86)” como padrão clicando no botão “Avançar”.

Em “Configuração da Instância” escolheremos a opção “Instância nomeada” como “SQLExpress” e em “Configuração do Servidor” deixaremos como a Microsoft recomenda, ou seja, uma conta separada para cada serviço do SQL Server. Ver Figura 07.

Figura 07:Configuração do Servidor.

Deveremos especificar o modo de segurança da autenticação, os diretórios de dados e as configurações de TempDB do Mecanismo de Banco de Dados. Na aba “Configuração do Servidor” deixaremos como Modo de autenticação “Misto” (autenticação do BD e do Windows) especificando uma senha de administrador. Clicaremos no botão “Adicionar Usuário Atual” para adicioná-lo em nossa lista de acesso.

Nas abas “Diretório de Dados”, “TempDB”, “Instâncias de Usuário” e FILESTREAM” deixaremos as configurações padrões. Ver Imagem 08.

Figura 08: Configuração do Mecanismo de Banco de Dados.

Iremos configurar e instalar o “Reporting Services” no próximo passo clicando em Avançar. Já no item “Consentimento para instalar o Microsoft R Open” baixaremos alguns pré-requisitos necessários.

Importante: A instalação demorará cerca de 30 à 60 minutos, dependendo do hardware utilizado.

Na Imagem 09 teremos a conclusão da instalação com êxito.

Figura 09: Conclusão da Instalação.

Conclusões

Neste artigo procurei descrever todas as etapas para adquirir e instalar o Microsoft SQL Server 2016 Release Candidate 3. Em artigos futuros irei explorar outros itens deste banco de dados, fica a dica para quem deseja testar seus projetos nesta nova ferramenta da Microsoft.

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

Referências

https://www.microsoft.com/pt-br/evalcenter/evaluate-sql-server-2016?lc=1046

Principais recursos do Microsoft SQL Server 2016

2019-04-11T11:46:00.002-03:00

No artigo deste mês irei explorar alguns recuros do lançamento da nova versão do Banco de Dados da Microsoft, o Microsoft SQL Server 2016. Terei como base o E-Book gratuito escrito por Stacia Varga, Denny Cherry E Joseph D’ Antoni que está disponível no formato “pdf” no seguinte link:

http://aka.ms/IntroSQLSvr2016PE_dsktp_pdf

É importante informá-los que o lançamento oficial foi no dia 07 de Abril de 2016 e sua versão “SQL Server 2016 Release Candidate 2” poderá ser baixada e instalada através do link:

https://www.microsoft.com/pt-br/evalcenter/evaluate-sql-server-2016

A ideia central deste artigo será de apenas apontar e explorar algumas novidades encontradas nesta nova versão do banco de dados, sempre tendo como base o E-book supracitado, ou seja, não abordarei instalações, configurações, entre outros recursos que explorarei com certeza em artigos futuros.

1) Segurança mais rígida

O Microsoft SQL Server 2016 introduz diversos novos recursos relacionados à segurança de dados, sendo: “Always Encrypted“, “Row-Level Security” e “Dinamic Data Masking”. Abaixo irei descrever todos estes recursos.

- Always Encrypted

Traduzindo para o português como “Sempre Crptografados”, é denominado como uma tecnologia de criptografia do lado do cliente no qual os dados são automaticamente criptografados não apenas quando é escrito, mas também quando ele é lido por um outro aplicativo. Ao contrário de criptografia de dados transparente, que criptografa os dados no disco. Sua principal característica ao utilizar este tipo de controle, é que a aplicação transfere de forma segura os dados criptografados no banco de dados que pode ser descriptografado depois apenas por um aplicativo que tem acesso à chave de criptografia.

Exemplo:

CREATE TABLE dbo.EXEMPLO_CRIPTOGRAFIA

(

CODIGO INT IDENTITY(1,1) PRIMARY KEY,

NOME VARCHAR(50),

DOCUMENTO VARCHAR(30),

DATA_NASCIMENTO DATE ENCRYPTED WITH

(

ENCRYPTION_TYPE = RANDOMIZED,

ALGORITHM = ‘AEAD_AES_256_CBC_HMAC_SHA_256’,

COLUMN_ENCRYPTION_KEY = MINHA_CHAVE

TIPO CHAR(10) ENCRYPTED WITH

(

ENCRYPTION_TYPE = DETERMINISTIC,

ALGORITHM = ‘AEAD_AES_256_CBC_HMAC_SHA_256’,

COLUMN_ENCRYPTION_KEY = MINHA_CHAVE

));

No exemplo acima, na criação do campo definimos o tipo, o algoritmo e a chave de criptografia. Utilizamos nos campos “DATA_NASCIMENTO” e “TIPO” através do comando “ENCRIPTED WITH”.

- Row-Level Security

Este tipo de recurso permite configurar tabelas de tal forma que os usuários vejam apenas as linhas dentro da tabela para a qual iremos conceder acesso. A “Row-Level Security” permitirá aos DBAs e profissionais da área de banco de dados, realizar um controle de acesso aos dados que estão armazenados em determinadas tabelas, através do uso de funções conhecidas como “Predicate”, limitando assim que uma possível coluna e seu respectivo valor seja consultado.

Poderemos usar um “predicate” para filtrar silenciosamente as linhas que são acessíveis pelo usuário ao usar “INSERT”, “UPDATE” ou “DELETE”. Além disso, poderemos também usá-los para o usuário de gravar dados através das cláusulas: “AFTER INSERT”, “AFTER UPDATE”, “BEFORE UPDATE” e “BEFORE DELETE”.

Exemplo:

CREATE SCHEMA Seguranca

CREATE FUNCTION Seguranca.acessoUsuarioPredicate(@UserName sysname)

RETURNS TABLE

WITH SCHEMABINDING

RETURN SELECT 1 AS accessResult

WHERE @UserName = SUSER_SNAME()

CREATE SECURITY POLICY Seguranca.acessoUsuarioPolicy

ADD FILTER PREDICATE Seguranca.acessoUsuarioPredicate(UserName) ON dbo.Tabela,

ADD BLOCK PREDICATE Seguranca.acessoUsuarioPredicate(UserName) ON dbo.Tabela

No código acima foi criado uma função para adicionar e bloquear um usuário em uma determinada tabela.

- Dynamic data masking

O Dynamic Data Masking, limita a exposição de dados confidenciais, os mascarando para usuários não-privilegiados. O Mascaramento de dados dinâmico ajuda a evitar o acesso não autorizado a dados confidenciais, permitindo aos clientes designar o quanto os dados confidenciais para revelar com impacto mínimo na camada de aplicação. É uma característica de segurança que esconde os dados no conjunto de resultados de uma consulta sobre campos de banco de dados designado, enquanto os dados no banco de dados não são alterados. Considerado de fácil utilização com aplicativos existentes, desde que as regras de mascaramento sejam aplicadas nos resultados da consulta. Muitos aplicativos podem mascarar dados confidenciais sem modificar consultas existentes.

Exemplo:

CREATE TABLE PESSOAS

(
ID int IDENTITY PRIMARY KEY,

NOME varchar(100) MASKED WITH (FUNCTION = 'partial(1,"XXXXXXX",0)') NULL,

SOBRENOME varchar(100) NOT NULL,

FONE varchar(12) MASKED WITH (FUNCTION = 'default()') NULL,

Email varchar(100) MASKED WITH (FUNCTION = 'email()') NULL

);

Ao criar os campos na tabela PESSOAS poderemos incorporar algumas máscaras existentes nesta nova versão do SQL Server, como por exemplo: “PARTIAL”, “DEFAULT” e “EMAIL”, ambas precedidas do comando “MASKED”.

2) Melhorias no Motor do Banco de Dados

No Microsoft SQL Server 2016, poderemos encontrar uma funcionalidade melhorada em todo o

motor (engine) do banco de dados passando a gerir mais de um número muito maior de bases de

dados SQL Server por meio de seu banco de dados como um serviço (DBaaS). Neste item, vamos

explorar algumas das novas funcionalidades dos denominados “Query Store” e “Stretch Database”.

- Query Store

Esta funcionalidade irá nos auxiliar em muito em nossas longas jornadas de análise de planos de execução, a “Query Store” vai dar a possibilidade de fazer a análise de uma plano de execução que possa estar apresentando problemas de desempenho através de uma “indicação” ou “orientação” por parte do SQL Server, podendo escolher um plano de execução para processar uma query.

Podemos considerar esta característica como uma das maiores melhorias para o motor de
banco do dados SQL Server, desde a introdução de pontos de vista de gerenciamento dinâmico.
Podemos corrigir diversos tipos de problemas acarretando uma maior velocidade dos dados.

Exemplo: Habilitando o “Query Store” sem parâmetros.



ALTER DATABASE dbTheClub SET QUERY_STORE = ON;

Exemplo: Habilitando o “Query Store” com parâmetros.

ALTER DATABASE dbTheCLub

SET QUERY_STORE = ON

(

OPERATION_MODE = READ_WRITE,

CLEANUP_POLICY = (STALE_QUERY_THRESHOLD_DAYS = 5),

DATA_FLUSH_INTERVAL_SECONDS = 2000 ,

MAX_STORAGE_SIZE_MB = 10 ,

INTERVAL_LENGTH_MINUTES = 10

);

Exemplo de utilização do “Query Store”

SELECT TOP 10 rs.avg_duration,
qt.query_sql_text,

q.query_id,
qt.query_text_id,
p.plan_id,
GETUTCDATE() AS CurrentUTCTime,

rs.last_execution_time

FROM sys.query_store_query_text AS qt

JOIN sys.query_store_query AS q ON qt.query_text_id = q.query_text_id

JOIN sys.query_store_plan AS p ON q.query_id = p.query_id

JOIN sys.query_store_runtime_stats AS rs ON p.plan_id = rs.plan_id

WHERE rs.last_execution_time > DATEADD(hour, -1, GETUTCDATE())

ORDER BY rs.avg_duration DESC;

Na utilização de “Query Stores” teremos diversos tipos, como:

query_store_query_text: Texto da consulta digitado pelo usuário, incluindo espaços em branco, sugestões e comentários.

query_store_query: Informações de consulta e as suas estatísticas de execução.

query_store_plan: informações de plano de execução para consultas.

query_store_runtime_stats: estatísticas de tempo de execução para consultas.

- Stretch Database

Esta é uma funcionalidade bastante esperada principalmente para os usuários do Azure, através do “Strech Database”, em português ficaria mais ou menos como “Base de Dados de Estiramento”, será possível armazenar porções (partes ou fatias) de uma tabela no “Azure SQL Database”. Através deste recurso, temos a capacidade de armazenar dados históricos contidos em uma tabela de forma segura e transparente diretamente na nuvem, ou melhor dizendo no Microsoft Azure. A partir do momento que este recurso é habilitado, de forma silenciosa os dados considerados históricos são migrados para um banco SQL Azure, tudo isso é feito pelo SQL Server sem exigir qualquer alteração de código em sua query ou aplicação.

Importante: Para realizar estes teste é necessário possuir uma conta Azure.

Exemplo para configurar a opção “REMOTE DATA ARCHIVE”:

EXEC sp_configure 'remote data archive', '1';

GO RECONFIGURE;

Ou também podemos facilmente configurar via interface gráfica, clicando com o botão direito sobre a base de dados escolhendo “Tasks” e logo em seguida “Enable Database for Stretch...”

Ver Imagem 01.

Figura 01: Configurando o “Database for Stretch...”

Conclusões

Procurei neste artigo discorrer um pouquinho das principais novidades desta novíssima versão do Banco de Dados SQL Server.

De acordo com minhas pesquisas e leituras de artigos, a própria Microsoft está muito confiante neste novo banco, o mesmo está promentendo ser ainda mais robusto para aplicações de pequeno, médio e grande porte.

Aproveito para indicar fortemente a leitura do e-book citado no ínicio do artigo para quem desejar obter informações mais profundas sobre os assuntos abordados neste artigo, assim como outros inúmeros que poderão encontrar lá com minuciosos detalhes.

Este é o primeiro de muitos artigos que a nossa equipe irá preparar para você.

Desejo a todos uma ótima leitura. Um abraço!

Referências

https://www.microsoft.com/pt-br/evalcenter/evaluate-sql-server-2016
https://msdn.microsoft.com/en-us/library/bb669076(v=vs.110).aspx
https://msdn.microsoft.com/en-us/library/mt130841.aspx

JSON - Conceitos Básicos

2019-04-11T11:34:00.001-03:00

Neste mês irei abordar conceitos básicos sobre um assunto muito utilizado na atualidade, o JSON. Podemos definir JSON (Javascript Object Notation) como um modelo para armazenamento e transmissão de informações no formato texto, independente de qualquer linguagem de programação.

Este formato é nativo do Javascript e é de uso extremamente fácil. Podemos utilizar este formato em diversas plataformas de desenvolvimento, sendo que o mais usual seria por aplicações Web, devido a sua capacidade de estruturar informações de uma forma bem mais compacta do que o modelo XML, tornando mais rápido o “parsing” (processo de analisar uma sequência de entrada dessas informações) dessas informações.

É importante lembrarmos que existem uma variedade de opções de protocolos abertos padronizados, tais como SOAP, XML, entre outros, que podem ser adotados e isso vai depender da finalidade e dos requisitos da sua aplicação.

Principais características

Podemos destacar algumas características marcantes como:

· Auto-Descritivo;

· Simples e mais rápido;

· Hieráquico (valores dentro de valores);

· Pode ser Analisado pelo Javascript;

· Os dados podem ser transportados usando o AJAX;

· Não utiliza a tag de fechamento;

· Utiliza matrizes (diferente do XML);

· Não possui palavras reservadas;

· Possui “parser” nas principais linguagens e navegadores.

Antes de iniciarmos o uso do JSON, gostaria de demonstrar algumas diferenças entre o formato XML, o qual já estamos mais habituados.

Ver Tabela 01.

Uma comparação entre JSON e XML

Características

JSON

XML

Tipos de Dados

Fornece tipos de dados escalares e a capacidade de expressar dados estruturados através de matrizes e objetos.

Não fornece qualquer noção de tipos de dados. É preciso contar com Schema XML para adicionar informações de tipo.

Suporte para Matrizes

Possui suporte nativo a matrizes.

Matrizes têm de ser expressos por convenções , por exemplo através da utilização de um elemento de espaço reservado exterior que modelos o conteúdo matrizes como elementos internos.

Suporte para Objetos

Possui suporte nativo aos objetos.

Objetos devem ser expressos muitas vezes através de um uso misto de atributos e elementos.

Suporte a elementros Nulos

Nativamente reconhece o valor nulo.

Requer o uso de “xsi : nil” em elementos em um documento de instância XML além de uma importação do namespace correspondente.

Comentários

Não suporta este tipo de recurso.

O suporte nativo é geralmente disponíveis através de APIs .

Namespaces

No conceito de namespaces as colisões de nomenclatura geralmente são evitados pelo aninhamento objetos.

Suporta namespaces , o que elimina o risco de colisões de nomes ao combinar documentos. Namespaces também permitem padrões baseados em XML existentes para ser estendido com segurança.

Formatação

Fornece um mapeamento muito mais direto para dados de aplicativo.

Requer um esforço maior para decidir como mapear tipos de aplicativos para elementos e atributos XML.

Tamanho

A sintaxe é muito concisa e produz texto formatado , onde a maioria do espaço é utilizada pelos dados representados .

Documentos tendem a ser longos.

Análise (parsing) no Javascript

Podemos usar a função “eval” do JavaScript.

Requer uma implementação “DOM” “XML” e código de aplicação adicional para mapear o texto de volta para objetos JavaScript.

Curva de Aprendizado

Tecnologia muito simples que já é familiar aos desenvolvedores com experiência em JavaScript ou outras linguagens de programação dinâmica.

Geralmente tende a exigir a utilização de várias tecnologias como por exemplo: XPath , XML Schema , XSLT, XML Namespaces , DOM , e assim por diante.

Tabela 01: Comparação entre JSON e XML.

Sintaxe

Podemos definir algumas regras de sintaxe, como: os dados são definidos aos pares no formato “nome: valor”, são separados por vírgulas, as chaves { } contém objetos e os colchetes [ ] expressam matrizes e vetores.

Exemplo:

“razaosocial”: “the club”

1) Valores do tipo texto

Para valores do tipo texto devemos inserir a aspas duplas ( “ “ ).

Exemplo:

“razaosocial”: “the club”

2) Valor Real

Para este tipo de dados não utilizamos aspas.

Exemplo:

“distancia”: 5.85

3) Valor Negativo

Para este tipo de dados não utilizamos aspas.

Exemplo:

“grau”: -90

4) Valor booleano

Para este tipo de dados não utilizamos aspas.

Exemplo:

“liberado”: false

A partir dos tipos básicos, é possível construir tipos complexos: array e objeto. Os arrays são delimitados por colchetes [ ], com seus elementos separados entre vírgulas.

5) Valor Array de Strings

Os valores são delimitados por colchetes, vírgula e aspas duplas.

Exemplo:

[“SIM”, “NÃO”, “TALVEZ”, “QUEM SABE”]

6) Valores de Array de Inteiros

Os valores são delimitados por colchetes e vírgula.

Exemplo:

[1, 10, 20, 30, 40, 50]

7) Valores de Matriz de Inteiros

Os valores são delimitados por colchetes e vírgula.

Exemplo:

[
[1,2], [10. 20], [20,30]
]

Já os objetos são especificados entre chaves e podem ser compostos por múltiplos pares nome/valor, por arrays e também por outros objetos. Desta forma, um objeto JSON pode representar, virtualmente, qualquer tipo de informação. Podemos conferir nos itens 8 e 9.

8) Valores de Objetos

Exemplo:

{
“nome”: “Thiago C. Montebugnoli”,
“documento”: “333.222.555-99”,
“sexo”: “masculino”,
“tipopessoa”: [“juridica”, “fisica”]
}

9) Valores de Array de Objetos

Exemplo:

[

{
    “nome”: “Thiago C. Montebugnoli”,
    “documento”: “333.222.555-99”,
    “sexo”: “masculino”,
    “ativo”: true,
    “tipopessoa”: [“juridica”, “fisica”]
},
{
    “nome”: “Marcos Cesar”,
    “documento”: “333.888.666-99”,
    “sexo”: “masculino”,
    “ativo”: false,
    “tipopessoa”: [“juridica”, “fisica”]
}

]

10) Valor nulo

Para referenciar valores nulos basta utilizar a palavra “null”.

Exemplo:

“atualizado”: null

Exemplo prático - Criando Objetos a partir do JSON

A partir deste momento irei demonstrar na prática um exemplo simples envolvendo JSON junto com páginas simples em HTML. Para isto abra o Bloco de Notas ou outro aplicativo similar para darmos procedimento ao nosso exemplo.

<!DOCTYPE html>
<html>
<body>
<h2>Criando Objetos a partir do JSON</h2>
<p id="theclub"></p>
<script>
var text = '{"funcionarios":['
+'{"nome":"Thiago","sobrenome":"Montebugnoli" },' +'{"nome":"Marcos","sobrenome":"Cesar" },' +'{"nome":"Bruno","sobrenome":"da Silva" }]}';
obj = JSON.parse(text);
document.getElementById("theclub").innerHTML = obj.funcionarios[1].nome + " " + obj.funcionarios[1].sobrenome;
</script>
</body>
</html>
Listagem 01.

Como foi descrito anteriormente, foi criado um array de objetos, no caso de funcionários, contendo os pares valores de Nome e Sobrenome. Armazenaremos em uma variável do tipo “var” dentro da tag “script”. A função Javascript “JSON.parse” está sendo utilizada para converter um texto JSON em um objeto Javascript. O método “getElementById.innerHTML” irá escrever no navegador os dados contidos na posição “1” do array de objetos supracitado. Ver Listagem 01 para maiores detalhes.Podemos conferir o resultado deste código na Imagem 01.

Figura 01: Criando Objetos a partir do JSON.

Conclusões

Caro leitor, a minha ideia neste artigo foi de apontar os conceitos iniciais deste modelo para armazenamento e transmissão de informações no formato texto. Foram demonstradas algumas diferenças relevantes entre JSON e XML e logo em seguida procurei detalhar o máximo possível de conceitos envolvendo exemplos simples e intuitivos.

O JSON é considerado um importante e indispensável protocolo de troca de dados, tendo algumas empresas que o adotam, como por exemplo: Google e Yahoo, as quais necessitam transmitir grandes volumes de dados entre aplicações.

Vou Ficando por aqui, um forte abraço e até o mês que vem!

Referências

http://www.w3schools.com/json/

https://msdn.microsoft.com/en-us/library/bb299886.aspx

Linguagem C# - Ftp de Arquivos – Parte 2

2019-04-11T11:30:00.002-03:00

Caro amigo, neste mês irei explorar a segunda parte do artigo sobre FTP de arquivos utilizando a linguagem C# junto com a plataforma Windows Forms. No mês passado criamos uma classe chamada “Ftp”, contendo o método necessário para a realização do Upload de arquivos. Neste mês de Fevereiro irei ensiná-los a realizar o “Download” de arquivos deste mesmo servidor. Para isto criarei uma interface implementando métodos desta mesma classe Ftp.

Utilizaremos as duas classes descritas no artigo de Janeiro, sendo a: “FtpWebRequest” e a “FtpWebResponse”. Para maiores detalhes recomendo a leitura da primeira parte deste artigo.

Reutilizando a Classe Ftp

Iremos implementar mais dois métodos na classe FTP, sendo:

“ListarArquivos”: Responsável por trazer todos os arquivos contidos no servidor FTP, nos permitindo fazer a escolha do arquivo a ser baixado.

“Download”: Rotina necessária para realizar o download do arquivo escolhido.

Deveremos também implementar mais alguns atributos, como: “ftpResponse”, “ftpStream” e “bufferSize”.

Ambos os métodos e atributos serão explicados a seguir.

Declarando os atributos necessários:

private FtpWebResponse ftpResponse = null;

private Stream ftpStream = null;

private int bufferSize = 2048;

Na função “Download” passaremos por parâmetros o caminho do arquivo contido no servidor FTP e na máquina local. Teremos um retorno booleano para indicar se a rotina foi realizada ou não com sucesso. Primeiramente instanciamos a classe “FtpWebRequest” fornecendo o endereço do servidor e local. Para o método “Credentials” atribuímos o usuário e senha do FTP. Utilizaremos configurações como “UseBinary” para arquivos binários, “UsePassive” para definir o comportamento do processo de transferência de dados de um aplicativo, “KeepAlive” para especificar se a conexão de controle para o servidor FTP é fechada depois que a solicitação for concluída. O próximo passo seria identificar o tipo de tarefa através do atributo “Method”. Para isto escolheremos “DownloadFile” e logo em seguida estabelecemos um retorno do servidor FTP através do método “GetResponse”. O atributo “ftpStream” irá nos auxiliar para testarmos o “Download” do arquivo através de uma rotina “Try/Catch”. Ver Listagem 01.

public bool Download(string remoteFile, string localFile)

{

try

{

ftpRequest = (FtpWebRequest)FtpWebRequest.Create(enderecoFtp + "/" + remoteFile);

ftpRequest.Credentials = new NetworkCredential(usuario, senha);

ftpRequest.UseBinary = true;

ftpRequest.UsePassive = true;

ftpRequest.KeepAlive = true;

ftpRequest.Method = WebRequestMethods.Ftp.DownloadFile;

ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();

ftpStream = ftpResponse.GetResponseStream();

FileStream localFileStream = new FileStream(localFile, FileMode.Create);

byte[] byteBuffer = new byte[bufferSize];

int bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);

try

{

while (bytesRead > 0)

{

localFileStream.Write(byteBuffer, 0, bytesRead);

bytesRead = ftpStream.Read(byteBuffer, 0, bufferSize);

}

catch

{

return false;

}

localFileStream.Close();

ftpStream.Close();

ftpResponse.Close();

ftpRequest = null;

}

catch

{

return false;

}

return true;

}

Listagem 01.

A rotina “Listararquivos” possui como parâmetro de entrada o diretório onde os arquivos se encontram no servidor FTP. Ela nos retorna um Array de Strings, contendo todos os nomes dos arquivos do endereço fornecido. Iniciamente utilizaremos exatamente as mesmas opções descritas no método “Download”. Usaremos o método “WebRequestMethods.Ftp.ListDirectory” para listar os arquivos do diretório indicado. Iremos ler linha por linha armazenando na variável “directoryRaw” e separada por um pipe “|”. Por final, retornaremos a variável “directoryList” contendo todos os nomes dos arquivos. Ver Listagem 02.

public string[] ListarArquivos(string directory)

{

try

{

ftpRequest = (FtpWebRequest)FtpWebRequest.Create(enderecoFtp + "/" + directory);

ftpRequest.Credentials = new NetworkCredential(usuario, senha);

ftpRequest.UseBinary = true;

ftpRequest.UsePassive = true;

ftpRequest.KeepAlive = true;

ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;

ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();

ftpStream = ftpResponse.GetResponseStream();

StreamReader ftpReader = new StreamReader(ftpStream);

string directoryRaw = null;

try

{

while (ftpReader.Peek() != -1) {

directoryRaw += ftpReader.ReadLine() + "|"; }

}

catch { }

ftpReader.Close();

ftpStream.Close();

ftpResponse.Close();

ftpRequest = null;

try

{

string[] directoryList = directoryRaw.Split("|".ToCharArray());

return directoryList;

}

catch { }

}

catch { }

return new string[] { "" };

}
Listagem 02.

Criando um exemplo prático

Nosso formulário deverá conter a seguinte estrutura: 4 pares de Labels e TextBox sendo (Endereço Ftp, Usuário, Senha e Download em), um Listbox contendo o descritivo “Arquivos”, onde serão adicionados os arquivos contidos no servidor FTP e o botão “Download”, o qual fará o trabalho de baixar o arquivo no servidor FTP. Ver Imagem 01.

Figura 01: Criando a interface gráfica para consumir a classe Ftp.

O método “RecuperarArquivosFTP”, que fará o trabalho de listar todos os arquivos do servidor FTP através do método “ListarArquivos” contidos na classe FTP. Invocaremos o mesmo logo após o método “InitializeComponent”, ou seja, quando carregamos os componentes na tela.

public FrmFTPDownload()

{

InitializeComponent();

RecuperarArquivosFTP();

}

private void RecuperarArquivosFTP()

{

Ftp ftp = new Ftp(txtEndereco.Text, txtUsuario.Text, txtSenha.Text);

string[] detailDirectoryListing = ftp.ListarArquivos("/thiago");

for (int i = 0; i < detailDirectoryListing.Count(); i++)

{

lstArquivos.Items.Add(detailDirectoryListing[i]);

}

No evento “Click” do botão “Download” usaremos a função “consistencias” (Implementada no artigo do mês de Janeiro). Esta função terá algumas pequenas alterações, como por exemplo a inclusão do campo “Download em:”, ver código abaixo:

if (txtDownload.Text.Length <= 0)

{

MessageBox.Show("O campo Download é de preenchimento obrigatório!", "Atenção", MessageBoxButtons.OK, MessageBoxIcon.Warning);

return false;

}

Por este motivo não incluirei por inteiro a mesma em nosso artigo deste mês.

Receberemos o nome do arquivo através da seleção do mesmo no ListBox. Através da instância da classe FTP passaremos para o método construtor os dados do endereço, usuário e senha e em seguida atribuímos para o método “Ftp.Download” o caminho absoluto do arquivo localizado no servidor FTP e o caminho absoluto local. Passaremos uma mensagem informando se o processo foi realizado com sucesso através do “MessageBox”.

private void btnDownload_Click(object sender, EventArgs e)

{

if (consistencias() == true)

{

String nomeArquivo = lstArquivos.SelectedItem.ToString();

Ftp ftp = new Ftp(txtEndereco.Text, txtUsuario.Text, txtSenha.Text);

if (ftp.Download("thiago/" + nomeArquivo, txtDownload.Text + nomeArquivo))

MessageBox.Show(string.Format("Download do arquivo {0} realizado com sucesso!", nomeArquivo), "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);

else

MessageBox.Show(string.Format("Ocorreu uma falha no download do arquivo {0}!", nomeArquivo), "Erro", MessageBoxButtons.OK, MessageBoxIcon.Error);

}

Podemos conferir o exemplo em Run-time na Figura 02.

Figura 02: Exemplo em Run-Time.

Conclusões

Nesta segunda e última parte aprendemos a implementar o uso de download de arquivos via FTP. Assim completamos o ciclo completo das principais tarefas envolvendo FTP através da linguagem C#.

Fica aí a dica, um abraço e até o mês que vem!

Referências

https://msdn.microsoft.com/pt-br/library/system.net.ftpwebresponse(v=vs.110).aspx

https://msdn.microsoft.com/pt-br/library/system.net.ftpwebrequest(v=vs.110).aspx

Características	JSON	XML
Tipos de Dados	Fornece tipos de dados escalares e a capacidade de expressar dados estruturados através de matrizes e objetos.	Não fornece qualquer noção de tipos de dados. É preciso contar com Schema XML para adicionar informações de tipo.
Suporte para Matrizes	Possui suporte nativo a matrizes.	Matrizes têm de ser expressos por convenções , por exemplo através da utilização de um elemento de espaço reservado exterior que modelos o conteúdo matrizes como elementos internos.
Suporte para Objetos	Possui suporte nativo aos objetos.	Objetos devem ser expressos muitas vezes através de um uso misto de atributos e elementos.
Suporte a elementros Nulos	Nativamente reconhece o valor nulo.	Requer o uso de “xsi : nil” em elementos em um documento de instância XML além de uma importação do namespace correspondente.
Comentários	Não suporta este tipo de recurso.	O suporte nativo é geralmente disponíveis através de APIs .
Namespaces	No conceito de namespaces as colisões de nomenclatura geralmente são evitados pelo aninhamento objetos.	Suporta namespaces , o que elimina o risco de colisões de nomes ao combinar documentos. Namespaces também permitem padrões baseados em XML existentes para ser estendido com segurança.
Formatação	Fornece um mapeamento muito mais direto para dados de aplicativo.	Requer um esforço maior para decidir como mapear tipos de aplicativos para elementos e atributos XML.
Tamanho	A sintaxe é muito concisa e produz texto formatado , onde a maioria do espaço é utilizada pelos dados representados .	Documentos tendem a ser longos.
Análise (parsing) no Javascript	Podemos usar a função “eval” do JavaScript.	Requer uma implementação “DOM” “XML” e código de aplicação adicional para mapear o texto de volta para objetos JavaScript.
Curva de Aprendizado	Tecnologia muito simples que já é familiar aos desenvolvedores com experiência em JavaScript ou outras linguagens de programação dinâmica.	Geralmente tende a exigir a utilização de várias tecnologias como por exemplo: XPath , XML Schema , XSLT, XML Namespaces , DOM , e assim por diante.