O Wireshark permite o uso da linguagem de programação Lua para criação de novos dissectors. Esta funcionalidade é interessante quando se tem um protocolo privado e gostaria de facilitar a visualização dos dados trafegados com a utilização do Wireshark.

Como criar um dissector novo?

Vamos criar um dissector atrelado a porta UDP 50000 como exemplo. Para isso, vamos adicionar um novo dissector para trabalhar em cima de um protocolo já existente, no caso UDP, com os pacotes destinados a porta 50000. O Wireshark só repassa ao dissector uma parte do buffer. No nosso caso, somente será repassado ao dissector o conteúdo do buffer destinado a porta 50000.

Código do dissector

Conteúdo do arquivo novoProtocolo.lua:

-- Vamos criar um novo dissector e seus campos
p_novoProtocolo = Proto ("novoProtocolo", "Novo Protocolo")
local f_campo1 = ProtoField.uint16("p_novoProtocolo.campo1", "Campo1", base.HEX)
local f_campo2 = ProtoField.string("p_novoProtocolo.campo2", "Campo2", base.HEX)

p_novoProtocolo.fields = {f_campo1, f_campo2}

-- Função principal do dissector novoProtocolo
function p_novoProtocolo.dissector (buf, pkt, root)
	-- É importante validar o tamanho do pacote recebido.
	if buf:len() <= 0 then
		return
	end

	-- Atribuição do nome que sera exibido na coluna "Protocol"
	pkt.cols.protocol = p_novoProtocolo.name

	-- Criação da subtree para o novoProtocolo
	subtree = root:add(p_novoProtocolo, buf(0))

	-- Adicionar os campos do novo protocolo ao subtree
	subtree:add(f_campo1, buf(0,2)):append_text(" [Detalhes do Campo 1]")
	subtree:add(f_campo1, buf(2,2)):append_text(" [Detalhes do Campo 2]")

	-- Descrição do payload
	subtree:append_text(", Alguns detalhes a mais.")
end

-- Rotina de inicialização.
function p_novoProtocolo.init()
end

-- Registrar um dissector atrelado a porta UDP 50000
local udp_dissector_table = DissectorTable.get("udp.port")
dissector = udp_dissector_table:get_dissector(50000)
udp_dissector_table:add(50000, p_novoProtocolo)

Rodando seu script Lua no Wireshark

Ainda é preciso algumas etapas antes de conseguir rodar o código acima. Se você tiver a versão 1.4 ou melhor, pule a etapa 3.

1. Salve o script lua acima em qualquer pasta. (ex. C:\NovoProtocolo) e chame o arquivo de novoProtocolo.lua
2. Abra o arquivo ini.lua, que se encontra no diretorio de instalação do Wireshark, para edição. Você precisará de privilégios de administrador no Windows Vista e 7.
3. Comente a seguinte linha no arquivo init.lua (Para comentar uma linha basta usar — no inicio da linha):

   disable_lua = true; do return end;

4. Adicione o seguinte código abaixo no arquivo init.lua (no final dele):

NOVOPROTOCOLO_SCRIPT_PATH="C:\\NovoProtocolo\\"
dofile(NOVOPROTOCOLO_SCRIPT_PATH.."novoProtocolo.lua")

Vide imagem abaixo da tela do Wireshark utilizando o Novo Protocolo.

Para validar o código demonstrado acima, é só baixar o pcap aqui.

Organização dos Dissectors

Entretanto é importante pensar na organização do código. Lua nos deixa bastante livre para decidirmos como organizar o código fonte. Você pode dividir seu código em quantos arquivos forem necessários e também coloca-los para serem carregados na ordem que você desejar. É possível carregar todos os arquivos na inicialização do Wireshark, ao colocar o código abaixo no final do arquivo init.lua no diretório aonde o Wireshark foi instalado.

PATH="C:\\NovoProtocolo\\"
dofile(PATH.."arquivo1.lua")
dofile(PATH.."arquivo2.lua")
dofile(PATH.."arquivo3.lua")
dofile(PATH.."arquivoN.lua")

Porem também é possível carregar seu código somente quando necessário, como no código exemplo abaixo:

if true then
dofile("C:\\NovoProtocolo\\arquivoN.lua")
end

Trabalhando com bitfields

A API Lua que o Wireshark usa não possui uma forma simples de se trabalhar com bitfield,porque eles só aceitam campos do tipo inteiro com máscara.

O wireshark 1.4.2 e anteriores tem um bug na API Lua. Eles só suportam bitfields (campos int com máscara), quando adicionado a um Proto definindo os campos do protocolo, assim como no exemplo abaixo:

-- criando novoproto e seus campos
p_novo = Proto ("novoproto","Novo Protocolo")
local f_bitfield = ProtoField.uint8("novoproto.bitfield", "Comando", base.HEX,
{[0]="Pacote Normal", [1]="Último Pacote"}, 0x40)
p_novo.fields = {f_bitfield}

Isso torna-se complicado caso você tenha um protocolo grande com vários bitfields, você terá que adicionar todos eles no inicio. Então coloco aqui uma função feita por Devendra Tewari que auxilia na exibição de bitfields.

-- Add a bit field to the dissection tree
-- buf - a tvb
-- subtree - dissection tree to which field will be added
-- offset - offset of the field within the tvb
-- size - number of octets containing the bitfield
-- bitfieldstart - start index of the bitfield, the highest bit is at 0
-- bitfieldlen - length of the bitfield to add
-- name - name of the field
-- valuestring - table containing description of bitfield value, can be nil
-- desc - description of the bit field
-- format - display format of the bitfield value, can be nil
function bitfield_add(buf, subtree, offset, size, bitfieldstart, bitfieldlen,
name, valuestring, desc, format)
    local val = buf(offset, size):bitfield(bitfieldstart, bitfieldlen)
    local binary=""
    local i = bitfieldlen - 1
    local intval = val

    repeat
        local result = intval % 2^i
        if result ~= intval then
            binary = binary.."1"
        else
            binary = binary.."0"
        end
        intval = result
        i = i - 1
    until (i < 0)

    local dotted = string.rep(".", bitfieldstart)..binary
      ..string.rep(".", size*8-bitfieldstart-bitfieldlen)

    local chunked = ""
    for i = 0, size do
        chunked = chunked..string.sub(dotted, 8*i+1, 8*i+4)
          .." "..string.sub(dotted, 8*i+5, 8*i+8).." "
    end

    desc = chunked.." = "..desc
    if format ~= nil then
        desc = desc..": "..string.format(format, val)
    end

    if valuestring ~= nil then
        if valuestring[val] ~= nil then
            desc = desc.." ["..valuestring[val].."]"
        end
    end

    subtree:add(ProtoField.uint8(name), buf(offset, size), desc)
end

Sua única limitação é que o Wireshark irá destacar todos os octetos que contêm o bitfield, se você ativar Bit View no painel mais abaixo (terceiro), o Wireshark não irá destacar somente os bits referentes ao campo de bits.

Como colorir seu protocolo no Wireshark

O Wireshark tem uma funcionalidade bem interessante e útil quando precisamos analisar grandes logs capturados. Ele nos permite configurar filtros para cada protocolo e assim colorir cada ocasião que aquele protocolo aparecer. Como pode ser visto na imagem abaixo:

• Para fazer isso basta ir no menu View/Coloring Rules…
• Clique no botão de criar novo, irá abrir uma nova janela.
• No primeiro campo dê um nome ao filtro que será criado.
• No segundo campo informe o nome do protocolo que será filtrado.
• Logo abaixo escolha as cores e dê ok.
• Posicione o seu novo filtro acima da camada onde seu protocolo roda. Por exemplo: Se o seu protocolo roda em cima de TCP, então coloque seu filtro logo acima do filtro de TCP.

Como a ferramenta já diz, levar a impressão pras nuvens. Ao conectar o seu navegador ‘Google Chrome’ à conta do ‘Google Cloud Print’, ele permite que todas as impressoras que o navegador tenha acesso, sejam jogadas nas núvens, para futuras impressões, e o melhor, de qualquer computador / smarthphone, independente de onde você estiver.

A princípio devemos acessar: http://www.google.com/cloudprint e fazer o login para integrar a conta do google com o cloudprint, caso você não esteja no utilizando o ‘Google Chrome’ que é um fator fundamental para configurar as impressoras que serão usadas nas nuvens, ele irá sugerir para o download.

Feito isso, vá em Opções (Options) -> Opções Avançadas (Under the hood) -> Na última opção faça o login no cloudprint e configure as impressoas que estarão disponívels para uso. “Google Cloud Print lets you access this computer’s printers from anywhere. Sign in to enable.”

Com tudo configurado, vamos ao código.

A princípio a permissão de acesso a INTERNET no Manifest da sua aplicação, para que a Activity que fará a conexão com o google possa mostrar o conteúdo do site no seu webview.

// permissão para uso da internet
<uses-permission android:name="android.permission.INTERNET" />

Basicamente, o código em si é esta chamada de Activity onde o programador irá passar o documento em forma de URI e seu MimeType (Uma lista de tipos pode ser encontrada aqui), e o título no qual o documento terá na lista de arquivos que estão sendo impressos.

Intent printIntent = new Intent(this, PrintDialogActivity.class);
printIntent.setDataAndType(docUri, docMimeType);
printIntent.putExtra("title", docTitle);
startActivity(printIntent);

Um exemplo seria a impressão de um PDF, para demonstração utilizo a biblioteca iText (http://www.itextpdf.com/) que é OpenSource e utilizada em Java e C#. Após adicionar o arquivo .jar ao Build Path do seu projeto no eclipse, basta criar um arquivo no SDcard, lembrando que precisamos de criar uma permissão para esse feito:

// permissão para escrever no armazenamento externo
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

// pega o armazenamento externo
File root = Environment.getExternalStorageDirectory();
// instancia um arquivo que será criado no diretório base do SDCARD
File file = new File(root, "teste.pdf");
// se o arquivo já existir, delete-o
if (file.exists())
    file.delete();
// tente criar um arquivo temporário
try {
    file.createNewFile();
} catch (IOException e) {
}

// criamos um documento do tipo PDF
Document document = new Document();
try {
    // avisamos ao PdfWriter que esse documento será salvo
    // na minha instancia de file para que
    // ao fechados o documento ele salve o arquivo
    PdfWriter.getInstance(document, new FileOutputStream(file));
    document.open();
    // adicionamos um paragrafo ao documento
    document.add(new Paragraph("Hello World!"));
} catch (DocumentException e) {
    e.printStackTrace();
}
document.close();

// e finalmente mandamos o arquivo para a Activity que
// fará a comunicação com o Google Cloud Print
Intent printIntent = new Intent(this, PrintDialogActivity.class);
printIntent.setDataAndType(Uri.fromFile(file), "application/pdf");
printIntent.putExtra("title", "PDF para ser impresso");
startActivity(printIntent);

O código da PrintDialogActivity juntamente com seu layout está disponível no site do projeto no google, e não precisa de nenhuma modificação, acesse para maiores informações: http://code.google.com/apis/cloudprint/docs/android.html

Outras bibliotecas PDF.

Continuando os post’s relacionados as informações do android,  iremos descobrir como captar o sinal da rede wireless em que o dispositivo está conectado.

Algumas aplicações em Android necessitam de uma quantidade considerável de processamento, memória e, conseqüentemente, de bateria dos dispositivos móveis. Dada o crescente desenvolvimento dessas tecnologias, bem como seu uso, vivemos em um cenário que a vida útil e a duração de bateria tem diminuído gradativamente. Este post tem como objetivo mostrar como descobrir informações referentes à bateria dos Smartphones e Tablets que utilizam a tecnologia Android.

Abaixo veremos um pequeno método responsável por recuperar o percentual de bateria disponível.

Nota: O método abaixo deve fazer parte de uma Activity onde será chamado. Mais informações sobre Activities aqui.

Para conseguirmos pegar essas informações necessitamos disparar através de um Intent-Filter para ACTION_BATTERY_CHANGED, também programamos um Broadcast( Ok, vcs já sabem oq achar aqui ) para ser executado quando essa Intent for disparada, e registramos esse Receiver para que possa escutar sempre que a Intent for disparada.

Na classe ACTION_BATTERY_CHANGED encontramos informações detalhadas da bateria, como status, nível, temperatura, voltagem, tecnologia da bateria e outras informações referentes à bateria, podemos encontrar quais informações estão disponiveis na classe BatteryManager no site do android developers.  Para lermos essas informações no broadcast, podemos executar essa tarefa utilizamos os métodos intent.getIntExtra, intent.getBooleanExtra e intent.getStringExtra.

Em breve outros post’s mostrando como descobrimos outras informações nativas dos dispositivos com Android.

* Este post foi redigido pela equipe C.E.S.A.R. Sorocaba

Neste post, pretendemos mostrar em mais detalhes a criação de um App Widget, ou Companion Widget (aquelas aplicações que podem ser colocadas na tela inicial do dispositivo). Veremos a criação de uma Activity para configuração do Widget, assim como a sua atualização, e a interação com o usuário. Um Widget pode ser adicionado várias vezes à tela, ou seja, pode haver várias instâncias do mesmo Widget sendo exibidas, e iremos tratar os eventos de forma distinta para cada uma delas.

Num post anterior, vimos que para construir um App Widget é necessário:

- criar uma subclasse de AppWidgetProvider, que será responsável pelo tratamento dos eventos do Widget;
- criar um arquivo XML de metadados do Widget;
- declarar o widget no AndroidManifest.xml;
- criar o layout do Widget, seguindo as limitações de uma RemoteView.

A classe AppWidgetProvider é uma sub-classe de BroadcastReceiver. Por este motivo, o ciclo de vida de um Widget é similar ao de um Broadcast Receiver, e não ao de uma Activity, além de ser necessário declarar os Widgets existentes do projeto como <receiver> no arquivo AndroidManifest.xml.

Como já foi citado naquele post, há cinco métodos de AppWidgetProvider que podem ser sobrescritos no nosso Widget, e cada um é executado em resposta a um broadcast específico (identificados aqui por constantes herdadas daquela classe):
- onEnabled(): Executado ao adicionar a primeira instância de um Widget na tela, em resposta ao broadcast ACTION_APPWIDGET_ENABLED. Pode ser utilizado, por exemplo, para fazer alguma configuração global da aplicação;
- onDisabled(): Executado ao remover a última instância do Widget da tela, como resposta ao broadcast ACTION_APPWIDGET_DISABLED. Pode ser usado para liberar algum recurso global/compartilhado da aplicação;
- onDeleted(): Executa sempre que uma instância do Widget é removida da tela, em resposta ao broadcast ACTION_APPWIDGET_DELETED. Neste método, podem ser liberados recursos utilizados por uma única instância;
- onUpdate(): Executa em resposta ao broadcast ACTION_APPWIDGET_UPDATE, ou seja, sempre que o Widget é adicionado à tela, quando expira o tempo configurado no atributo updatePeriodMillis do AppWidgetProviderInfo, ou quando o sistema é reiniciado. Segundo artigo do próprio site do Android, caso uma Activity de configuração tenha sido declarada, este método não é executado ao adicionar o Widget, mas apenas nas próximas atualizações. Desta forma, a Activity de configuração deve ser responsável por executar a primeira atualização do Widget;
- onReceive(): É executado em resposta a todos os broadcasts recebidos, e antes de cada um dos métodos acima. Na maioria dos casos, não é necessário sobrescrever este método, uma vez que todos os broadcasts já são filtrados pelo mesmo, na superclasse.

Apenas para demonstrar os conceitos abordados, iremos criar uma aplicação que exibe Toasts na tela do dispositivo, em intervalos configurados, além de alterar um TextView com a quantidade de atualizações ocorridas.

Criamos o projeto, desmarcando a opção para criar uma Activity (o que iremos fazer apenas para a configuração do nosso Widget). Adicionamos então uma nova classe ao nosso pacote, com o nome de WidgetProvider, extendendo a classe AppWidgetProvider. Por enquanto, sobrescrevemos o método onUpdate.

Os parâmetros deste método são:
- context: o Contexto atual do nosso broadcast receiver;
- appWidgetManager:  objeto que pode ser usado para atualizar ou obter informações sobre widgets;
- appWidgetIds: ids das instâncias deste widget que precisam ser atualizadas.

Como os eventos do widget serão tratados de forma distinta entre as suas instâncias, usaremos o parâmetro appWidgetIds para identificar a instância que os gerou, pois o Android reutiliza os Intents que tenham valores de Action e de Scheme semelhantes.

Em seguida, adicionamos o layout de nosso Widget, num arquivo com nome layout_widget.xml. Usaremos um layout simples, exibindo apenas um TextView com a quantidade de vezes Toasts exibidos a partir daquela instância:

<?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:gravity=”center”>
<TextView
android:layout_width=”fill_parent”
android:text=”@string/txtatualizacao”
android:layout_height=”wrap_content”
android:id=”@+id/txtatualizacao”
android:textColor=”#000000″ />
<Button
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”Atualizar”
android:id=”@+id/btatualizar” />
<Button
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”Resetar”
android:id=”@+id/btresetar” />
</LinearLayout>

Adicionamos agora o arquivo de meta-dados do Widget, aqui nomeado provider_info.xml. Os atributos da tag appwidget-provider devem ser compatíveis com os da classe AppWidgetProviderInfo. Neste exemplo iremos controlar o intervalo de atualização pela Activity de configuração. Portanto, omitimos o atributo updatePeriodMillis deste arquivo:

<?xml version=”1.0″ encoding=”utf-8″?>
<appwidget-provider     xmlns:android=”http://schemas.android.com/apk/res/android”
android:minWidth=”146dp” android:minHeight=”146dp”
android:updatePeriodMillis=”86400000″
android:initialLayout=”@layout/layout_widget”
android:configure=”cesar.org.br.WidgetConfiguration”>
</appwidget-provider>

Caso fôssemos utilizar este o atributo updatePeriodMillis, o intervalo  mínimo para atualização seria de 30 minutos, como forma de poupar a bateria do dispositivo. No arquivo acima, foram definidas também as dimensões mínimas do Widget, nos atributos minWidth e minHeight, e qual o layout a ser utilizado, em initialLayout.

Agora, é preciso declarar o Widget como um receiver no AndroidManifest.xml de nosso projeto, dentro da seção <application>:

<receiver
android:name=”.ToastWidgetProvider”>
<intent-filter>
<action android:name=”android.appwidget.action.APPWIDGET_UPDATE” />
</intent-filter>
<meta-data
android:name=”android.appwidget.provider”
android:resource=”@xml/imageswidget_info” />
</receiver>

Assim como no post anterior, adicionamos um Intent Filter com a Action APPWIDGET_UPDATE, e o nosso arquivo de meta-dados.

O próximo passo é criar a classe de configuração que tem o objetivo de proporcionar um mecanismo de configuração do widget.

As configurações podem ser de diversas espécies, como de mudanças de configuração de views que estão dentro do widget, propriedades do widget ou adição de uma view no widget.

Seguindo nosso exemplo iremos criar uma classe de configuração chamada WidgetConfiguration, ela deve ser herdar da classe Activity:

Como já visto em outros posts, uma activity deve ser declarada no manifesto, entretanto, além dessa configuração iremos fazer mais um passo no caso da nossa classe de configuração.

No manifesto teremos que adicionar o trecho do xml de configuração:

<activity
android:name=”.WidgetWidgetConfiguration”
android:label=”@string/app_name”>
<intent-filter>
<action
android:name=”android.appwidget.action.APPWIDGET_CONFIGURE” /> </intent-filter>
</activity>

Observe que diferente de uma Activity declarada de forma convencional no manifesto, ela possui um intent filter contendo uma ação que indica ser uma classe que configura um widget.

O próximo passo é indicar no xml de meta-dados que existe uma classe de configuração, para isso devemos adicionar um atributo:

android:configure=”cesar.org.br.ToastWidgetConfigure”

Por fim, para terminarmos a classe de configuração iremos implementar o método onCreate da Activity.

Existem duas maneiras de atualizar um widget, sendo a primeira delas a mais simples. Para isso basta atribuir um valor em milisegundos para o parâmetro updatePeriodMillis no AppWidgetProviderInfo, que, como já foi dito anteriormente, só aceita valores maiores que 30 minutos.

Para atualizar um widget com intervalos menores do que 30 minutos, é necessário criar um alarme. Um alarme é um serviço do android que permite que broadcasts sejam enviados para o sistema através do Intent registrado para o alarme. Para criar um alarme é necessário criar o Intent com os parâmetros relativos ao widget criado que será chamado cada vez que o tempo do alarme esgotar. A ação do Intent deverá ser AppWidgetManager.ACTION_APPWIDGET_UPDATE, que é a ação responsável por atualizar um widget.

Além da ação, é necessário informar ao Intent os IDs dos widgets a serem atualizados por esse Intent. Isso é feito colocando um vetor com os IDs que serão atualizados no extra AppWidgetManager.EXTRA_APPWIDGET_IDS do Intent. Também é necessário enviar a URI do seu widget, que faz com que apenas o seu widget receba a notificação. Caso a URI não seja enviada, todos os widgets do sistema serão notificados.

Com o Intent criado com todos parâmetros corretos, basta criar um PendingIntent com esse Intent. Para finalmente criar o alarme, basta obter o AlarmManager do sistema, e então chamar o método setRepeating desse AlarmManager, passando os parâmetros necessários, entre eles o tipo do alarme, o PendingIntent da operação e o intervalo de tempo desejado.

Vale lembrar que os alarmes registrados continuam executando mesmo após a remoção do widget. Portanto devemos cancelar esse alarme no método onDeleted do widget, que removerá o alarme relacionado à instância do widget removida.

Confira abaixo o código das principais classes e arquivos do projeto, e o resultado na tela do dispositivo:
Widget Provider
Activity de Configuração
AndroidManifest.xml
XML de meta-dados
Widget Layout

Dois widgets na tela inicial

Apesar dos diversos detalhes envolvidos, a criação de um App Widget não é tarefa das mais complicadas. Aplicando conceitos como Intents, Broadcast Receivers, Activities, e boas práticas de desnvolvimento para Android, é possível construir aplicações ricas em conteúdo, com a melhor performance possível.

Conceitos

O Cassandra armazena os dados usando o conceito de chave/valor, assim como o HBase; para aqueles que já usaram, e também usa o conceito de ColumnFamily, que agrupa um conjunto de colunas.

Instalando o Cassandra

No meu caso d:/ambiente/apache-cassandra-0.7.4. O Cassandra precisa de 3 diretórios para: dados, cache e logs, então criei como: D:/ambiente/Cassandra-dados, D:/ambiente/Cassandra-cache e D:/ambiente/Cassandra-logs, respectivamente. O importante aqui é modificar as propriedades no arquivo de configuração /cassandra-0.7.4/conf/Cassandra.yaml, indicando a localização dos diretórios, são elas: data_file_directories, saved_caches_directory e commitlog_directory.

Iniciando o Cassandra

Para iniciar o servidor execute o seguinte comando: cassandra –f  do diretório de instalação. Um log será exibido no console como na figura abaixo, e se nenhum erro aparecer, tudo estará funcionado bem.

Usando o Cliente

O Cassandra possui um cliente para linha de comando, vamos ver como este funciona. Para iniciar o cliente, execute o seguinte comando no diretório de instalação: cassandra-cli –host localhost –port 9160.

Crie um keyspace, na própria documentação do Cassandra é feita uma analogia com schema de bancos de dados relacionais, através do comando: create keyspace Pessoas.

Podemos notar que o keyspace foi criado no diretório /cassandra-data definido, como mostrado.

Aqui é necessário definir que você vai usar este keyspace, através do comando: use Pessoas. Após este passo, podemos definir nossa columnFamily, como mostrado na figura abaixo:

Instalação

O processo de instalação do MongoDB é bastante simples, basta realizar o download da versão Production Release de acordo com seu Sistema Operacional aqui. Neste artigo abordaremos a instalação no Windows, mas o processo é basicamente o mesmo em outros Sistemas Operacionais.
Após o download vamos descompactar o MongoDB é uma pasta qualquer, no meu caso D:\ e opcionalmente podemos renomear de mongo-xxxxxxx para apenas mongodb, ficando então em D:\mongodb.
O MongoDB  precisa da seguinte estrutura de pastas \data\db para armazenamento dos dados, só que a mesma não é criada automaticamente.  Então como nossa instalação está na unidade D:, vamos criar a estrutura de pastas D:\data\db.

Executando o servidor

Com tudo pronto, agora vamos executar o servidor do MongoDB. Para isso vamos executar o arquivo mongod.exe localizado na pasta bin pelo Explorer ou pela linha de comando conforme figura 1.

Figura 1. Executando o servidor MongoDB pela linha de comando.

Utilizando o cliente

Agora vamos iniciar um Shell administrativo executando o mongo.exe que também está localizado na pasta bin conforme figura 2.

Figura 2. Executando o cliente mongo.exe

Podemos perceber que por padrão o cliente conecta a base de dados test no servidor localhost. Digitando help o console exibe todos os comandos disponíveis.
Vamos digitar agora o comando:

> use mydb
switched to db mydb

Diferentemente de muitos bancos de dados existentes percebam que não é preciso executar um comando para criar um banco de dados. O mais interessante ainda é que o banco só é criado fisicamente quando os primeiros dados forem inseridos. Para confirmar executaremos o comando show dbs para exibir todos os bancos de dados:

> show dbs
admin   (empty)
local   (empty)
test    0.03125GB

Está na hora de adicionarmos algumas informações e consultá-las.

> objeto1 = { nome : "mongo" };
{ "nome" : "mongo" }
> registroNovo = { x : 3 };
{ "x" : 3 }
> db.minhaTabela.save(objeto1);
> db.minhaTabela.save(registroNovo);
> db.minhaTabela.find();
{ "_id" : ObjectId("4db5bda2eac9332a080885e8"), "nome" : "mongo" }
{ "_id" : ObjectId("4db5bdbdeac9332a080885e9"), "x" : 3 }

Agora vamos analisar o que foi executado. Inicialmente criamos dois objetos (documentos na nomenclatura do MongoDB): objeto1 e registroNovo. Percebam que eles possuem uma estrutura de campos totalmente diferente. Em seguida, adicionamos os dois objetos à tabela (coleção na nomenclatura do MongoDB) minhaTabela através do comando save(), na última linha realizamos uma consulta aos dados da tabela através do comando find().

Com isso passamos a entender o que seria o esquema dinâmico, onde não existe o conceito de estrutura de campos para uma tabela. Sendo o campo (chave na nomeclatura do MongoDB) _id criado automaticamente no momento do insert.

Bem pessoal, por enquanto é só. Aguardem os próximos posts sobre o MongoDB.

This class can activate the timer and notify the listeners.
This timer class is not a periodic timer, only a one-shot timer. If you want to carry out periodic tasks, you must start it again after it has fired.

It’s easy to use Timers in your app… lets see:

You must extend and construct your Timer

Extend (.h):

public Osp::Base::Runtime::ITimerEventListener

Construct(.cpp):

    __pTimer = new Timer();
    r = __pTimer->Construct(*this);
    r = __pTimer->Start(1000);

Implement OnTimerExpired (to start again your Timer), as shown below:

void
MyApp::OnTimerExpired(Timer& timer)
{

    ...

    timer.Start(1000);
}

Every time your timer ends, OnTimerExpired is called (so you can start your timer again).

Full example:

class MyApp
    : public ITimerEventListener
{
   ...
public:
    result InitTimer();
public:
    void OnTimerExpired(Timer& timer);
};

void
MyApp::OnTimerExpired(Timer& timer)
{

    ...

    timer.Start(1000);
}

result
MyApp::InitTimer()
{
    result r = E_SUCCESS;

    __pTimer = new Timer;

    r = __pTimer->Construct(*this);
    if (IsFailed(r))
    {
        goto CATCH;
    }

    __pTimer->Start(1000);
    if (IsFailed(r))
    {
        goto CATCH;
    }

    return r;
CATCH:
    return r;
}

A real example – implementing a bada Chronometer:
Construct:

    keepRunning = true;
    //get actual time and set as initial time when form is loaded.
    SystemTime::GetTicks(initialTime);
    __pTimer = new Timer();
    r = __pTimer->Construct(*this);
    r = __pTimer->Start(1000);

void
MyApp::Cronometer(){
 completeTime = "00:00:00";
 int diff, hour, minutes, seconds;
    String hourTxt, minutesTxt, secondsTxt;
 if(keepRunning){
  SystemTime::GetTicks(currentTime);
                //get actual time to make diff with initial time
  diff = (currentTime - initialTime);

  hour = Math::Floor((diff/1000)/60/60);
  minutes = Math::Floor((diff/1000)/60);
  seconds = Math::Floor((diff/1000)%60);
  if (seconds <= 9){
   secondsTxt = "0" + LongLong::ToString(seconds%60);
  }else if(seconds == 60){
   secondsTxt = "00";
   minutes++;
  }else{
   secondsTxt = LongLong::ToString(seconds%60);
  }

  if (minutes <= 9){
   minutesTxt = "0" + LongLong::ToString(minutes%60);
  }else if(minutes == 60){
   minutesTxt = "00";
   hour++;
  }else{
   minutesTxt = LongLong::ToString(minutes%60);
  }

  if (hour <= 9){
   hourTxt = "0" + LongLong::ToString(hour);
  }else if(hour == 24){
   hourTxt = "00";
  }else{
   hourTxt = LongLong::ToString(hour%24);
  }

  completeTime = hourTxt + ":"+ minutesTxt + ":"+ secondsTxt;

  Label *lblChrono = static_cast(GetControl(L"IDC_CHRONO"));
  if (null != lblChrono){
   lblChrono->SetText(completeTime);
   lblChrono->RequestRedraw(true);
  }

 }
    return;
}

void
MyApp::OnTimerExpired (Osp::Base::Runtime::Timer &timer)
{
 result r = E_SUCCESS;
        //call crhonometer to update label with time
 Cronometer();
        //start again - 1second period
 __pTimer->Start(1000);
 TryCatch(r == E_SUCCESS, , GetErrorMessage(r));
 return;

 CATCH:
  SetLastResult(r);
  return;

}

Thanks for your visit!

Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

i18n = internationalization – means of adapting computer software to different languages, regional differences and technical requirements of a target market. Internationalization is the process of designing a software application so that it can be adapted to various languages and regions without engineering changes. The terms are frequently abbreviated to the numeronyms i18n (where 18 stands for the number of letters between the first i and last n in internationalization, a usage coined at DEC in the 1970s or 80s).

8 steps to internationalize our bada apps:

Figure 1. Resource view: Double click in String table (as shown)

Figure 2. String view will be opened

Figure 3. Right click and choose Language Setting. Here you’ll select the languages that your app will give support.

Figure 4. Add the languages that your app will give support

Figure 5. String table view will be updated with selected languages

Figure 6. Right click and choose “insert” to fill the table with internationalized content. I suggest you to use IDs with some pattern name. Example: IDS_CLASSNAME_VARIABLENAME

Figure 7. String table with a content example

Figure 8. You can just associate the contents, created in String tables, with any control (labels, buttons, …)

If you need to internationalize any text that will not be constructed directly in any Form or Popup, you must insert the ID and content in String table and you can associate the created content to any control through code, as shown below:

...
//get controls
Label *lblContent = static_cast(GetControl(L"IDC_LABEL2CONTENT"));
Label *lblTitle = static_cast(GetControl(L"IDC_LABEL2MAINTITLE"));
Application* appStep = Application::GetInstance();
result r;
if(null!=lblContent && null!=lblTitle){
//get the string associated with an ID (String table) and
//save into titleTxt var
r = appStep->GetAppResource()->
    GetString(L"IDS_FORM2SCREENLBL_OBST_TITLE",titleTxt);
TryCatch(r == E_SUCCESS, , "GetAppResource is failed");
//set the internationalized text from String table to Label.
lblTitle->SetText(titleTxt);
lblTitle->RequestRedraw(true);
r = appStep->GetAppResource()->
    GetString(L"IDS_FORM2SCREENLBL_OBST_CONTENT",contentTxt);
TryCatch(r == E_SUCCESS, , "GetAppResource is failed");
lblContent->SetText(contentTxt);
lblContent->RequestRedraw(true);
...

You can change emulator language and test your bada i18n…

Thanks for your visit!
Feel free to ask/suggest/comment.
Twitter: @oliveiraeduardo

Websockets aparecem como uma interessante nova feature do HTML5. Essa feature define um canal de comunicação full-duplex através do qual mensagens podem ser trocadas entre o lado cliente e servidor de uma aplicação web de forma bidirecional. Abaixo temos uma imagem que mostra o atual suporte a websockets nos navegadores retirada da página http://caniuse.com/:

Assim como o HTML5, websockets ainda estão em versão draft, mas desenvolvedores podem começar a testar esse recurso implementando servidores que suportem uma das versões do protocolo e utilizar clientes que suportem a mesma versão. Atualmente alguns dos mais modernos browsers suportam a versão draft-hixie-thewebsocketprotocol-76 (http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76) também conhecida como draft-ietf-hybi-thewebsocketprotocol-00.

Neste post veremos como construir um protótipo de um simples servidor que suporta a versão draft-hixie-thewebsocketprotocol-76 do protocolo utilizando sockets em c#. O servidor será um console application que aceita uma conexão de websocket, recebe mensagens do cliente e envia os dados recebidos de volta em letras maiúsculas. No lado cliente usaremos uma página com HTML/javascript rodando sobre algum navegador que suporte a versão 76 do protocolo. Em testes durante a escrita deste post foi utilizada a versão mais atual do Chrome (no momento a 10.0.648.127).

Overview do projeto

Para estabelecer uma conexão via websocket cliente e servidor precisam se comunicar e verificar que conseguem falar na mesma língua, para isso é necessário se realizar um handshake. Abaixo um exemplo de handshake extraído do documento draft -hixie-thewebsocketprotocol-76:

Exemplo de mensagem de handshake vinda do cliente:

GET /demo HTTP/1.1
Host: example.com
Connection: Upgrade
Sec-WebSocket-Key2: 12998 5 Y3 1  .P00
Sec-WebSocket-Protocol: sample
Upgrade: WebSocket
Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5
Origin: http://example.com

^n:ds[4U

Exemplo de resposta vinda do servidor:

HTTP/1.1 101 WebSocket Protocol Handshake
Upgrade: WebSocket
Connection: Upgrade
Sec-WebSocket-Origin: http://example.com
Sec-WebSocket-Location: ws://example.com/demo
Sec-WebSocket-Protocol: sample

8jKS'y:G*Co,Wxa-

Explicando de uma forma simplificada, para completar o handshake o servidor precisa analisar a mensagem que veio do cliente e realizar algumas operações sobre os valores de Sec-WebSocket-Key1, Sec-WebSocket-Key2 e os últimos 8 bytes da mensagem (no exemplo acima representada pelo valor  ^n:ds[4U) e construir uma mensagem de resposta garantindo ao cliente que os dois lados sabem falar a mesma língua.

Uma vez tendo estabelecida a conexão, os dois lados podem trocar informações via data frames que são delimitados pelos bytes 0x00 e  0xFF e contém dados com codificação UTF-8 entre os delimitadores.

Todos os métodos para realizar o handshake e as trocas de mensagens estão explicados mais detalhadamente no projeto disponibilizado neste post, bem como a implementação de um cliente HTML/javascript. É necessário que antes de testar o projeto seja modificado o ip no arquivo de configuração do servidor (App.config) e no HTML como  é visto a seguir.

App.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
                      <!--Coloque seu ip aqui-->
    <add key="ipaddress" value="SEU_IP_AQUI" /> 

    <add key="port" value="8181" />
    <add key="location" value="ts" />

  </appSettings>
</configuration>

WebSocketClient.htm

<!--Substuir "SEU_IP_AQUI" pelo ip
                              que foi configurado no .config do servidor-->
    <input id="txtConnect" type="text" value="ws://SEU_IP_AQUI:8181/ts" />

    <input id="btnConnect" type="button" value="Connect" onclick="Connect()" />
    <br />
    <input id="txtSend" type="text" />
    <input id="btnSend" type="button" value="Send" onclick="Send()" />
    <input id="btnClose" type="button" value="Close" onclick="Close()" />
    </form>
</body>

Após configurar o App.config do servidor e o HTML do cliente basta rodar o servidor e acessar o arquivo HTML pelo browser. O projeto com o código pode ser acessado aqui: http://cid-2279647898802a3c.office.live.com/self.aspx/.Public/WebSocket76.zip e os arquivos do servidor e do cliente são os seguintes:

Program.cs

using System;
using System.Configuration;
using System.Net;
using System.Net.Sockets;

namespace WebSocket76
{
    class Program
    {
        static void Main(string[] args)
        {
            //Pega dados do arquivo de configuracao WebSocket76.exe.config
            //(App.config), nao esqueca de colocar seu ip la e no html tambem
            string ipAddress = ConfigurationSettings.AppSettings["ipaddress"];
            int port = int.Parse(ConfigurationSettings.AppSettings["port"]);

            string location = “ws://” + ipAddress + “:” + port
                + “/” + ConfigurationSettings.AppSettings["location"];

            TcpListener tcpListener =
              new TcpListener(new IPEndPoint(IPAddress.Parse(ipAddress), port));

            tcpListener.Start();

            Console.WriteLine(“Esperando conexão…”);
            Socket client = tcpListener.AcceptSocket();

            Console.WriteLine(“Tentativa de conexão iniciada…”);
            WebSocketServer wss = new WebSocketServer(client, location);

            Console.Read();
        }
    }
} 

WebSocketServer.cs

using System;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Threading;

namespace WebSocket76
{
    public class WebSocketServer
    {
        /// <summary>
        /// Socket usado como servidor
        /// </summary>
        private Socket _socketClient;

        /// <summary>
        /// Thread para receber dados do cliente
        /// </summary>
        private Thread _dataReceivedThread;

        /// <summary>
        /// Indica se o servidor esta ativo
        /// </summary>
        private bool _webSocketServerActive;

        /// <summary>
        /// Tamanho do buffer de recebimento de dados
        /// </summary>
        private const int BUFFER_SIZE = 1024;

        /// <summary>
        /// Indica se o handshake ja foi feito
        /// </summary>
        private bool _handShakeDone;

        /// <summary>
        /// Local do servidor
        /// </summary>
        private string _location;

        /// <summary>
        /// Construtor
        /// </summary>
        /// <param name="client">Socket para ser usado como servidor</param>
        /// <param name="location">Location</param>
        internal WebSocketServer(Socket client, string location)
        {
            _socketClient = client;
            _webSocketServerActive = true;
            _dataReceivedThread = new Thread(dataReceived);
            _dataReceivedThread.Start();

            _location = location;

            _handShakeDone = false;

        }

        /// <summary>
        /// Recebe dados do cliente e os trata
        /// </summary>
        private void dataReceived()
        {
            try
            {
                StringBuilder receivedDataString = new StringBuilder();

                while (_webSocketServerActive)
                {

                    byte[] data = new byte[BUFFER_SIZE];
                    int receivedDataLength = _socketClient.Receive(data);

                    //verifica se a conexao foi fechada
                    if (receivedDataLength < 1)
                    {
                        _webSocketServerActive = false;
                    }
                    else if (_webSocketServerActive)
                    {
                        //realiza handshake se o mesmo ainda nao tiver sido
                        //feito
                        if (!_handShakeDone)
                        {
                            Console.WriteLine("Iniciando handshake...");
                            StartHandShakeProcess(data, receivedDataLength);
                            _handShakeDone = true;
                        }
                        else //pega dados nos outros casos
                        {
                            System.Text.UTF8Encoding decoder =
                                new System.Text.UTF8Encoding();

                            string stringData =
                                decoder.GetString(data, 0, receivedDataLength);
                            receivedDataString.Append(stringData);

                            //Verifica se e o final da mensagem
                            if (receivedDataLength > 0 &&
                                (data[receivedDataLength - 1]
                                == BitConverter.GetBytes(0xFF)[0]))
                            {
                                string strData = receivedDataString.ToString();
                                strData = strData.Substring(1,
                                                           strData.Length - 2);

                                Console.WriteLine("DADOS RECEBIDOS: "
                                    + strData);

                                Console.WriteLine("Enviando dados" +
                                    " de volta para o cliente");

                                //envia a mensagem recebida de volta
                                //ao cliente com tudo em letras maiusculas
                                SendData(strData.ToUpper());

                                receivedDataString = new StringBuilder();
                            }
                        }
                    }
                }
            }
            catch
            {
                _webSocketServerActive = false;
            }
            finally
            {
                Console.WriteLine("Encerrando servidor");

                Shutdown();

                Console.WriteLine("Pressione enter para fechar o servidor");
            }
        }

        /// <summary>
        /// Finaliza servidor
        /// </summary>
        internal void Shutdown()
        {
            _webSocketServerActive = false;

            if (_socketClient != null && _socketClient.Connected)
            {
                _socketClient.Shutdown(SocketShutdown.Both);
                _socketClient.Close();
            }
        }

        /// <summary>
        /// Envia dados para o cliente
        /// </summary>
        /// <param name="data">Dados a serem enviados</param>
        internal void SendData(string data)
        {
            byte[] toSend = Encoding.UTF8.GetBytes(data);
            SendDataToClient(toSend);
        }

        /// <summary>
        /// Envia dados para o cliente de acordo com thewebsocketprotocol-76
        /// </summary>
        /// <param name="toSendBack"></param>
        private void SendDataToClient(byte[] toSendBack)
        {
            //Os dataframes sao delimitados pelos bytes 0x00 e 0xFF e
            //contem dados com codificacao UTF-8 entre esses delimitadores
            try
            {
                _socketClient.Send(BitConverter.GetBytes(0x00));
                _socketClient.Send(toSendBack);
                _socketClient.Send(BitConverter.GetBytes(0xFF));
            }
            catch
            {
                Shutdown();
            }
        }

        #region Handshake

        /// <summary>
        /// Iniicia o processo de handshake
        /// </summary>
        /// <param name="data">Handshake vindo do cliente</param>
        /// <param name="receivedDataLength">Tamanho dos dados recebidos</param>
        private void StartHandShakeProcess(byte[] data, int receivedDataLength)
        {
            byte[] last8Bytes = new byte[8];
            Array.Copy(data, receivedDataLength - 8, last8Bytes, 0, 8);

            System.Text.UTF8Encoding decoder = new System.Text.UTF8Encoding();
            string stringHandShakeRequest =
                decoder.GetString(data, 0, receivedDataLength - 8);

            DoHandShake(stringHandShakeRequest, last8Bytes);
        }

        /// <summary>
        /// Controi a resposta e a envia para o cliente
        /// </summary>
        /// <param name="stringHandShakeRequest">Parte inicial
        ///                                     do handshake</param>
        /// <param name="last8Bytes">Ultimos 8 bytes que compoem
        ///                          o handshake</param>
        private void DoHandShake(string stringHandShakeRequest,
                                 byte[] last8Bytes)
        {
            StringBuilder handShakeSB = new StringBuilder();

            handShakeSB.Append("HTTP/1.1 101 Web Socket Protocol Handshake"
                               + Environment.NewLine);
            handShakeSB.Append("Upgrade: WebSocket" + Environment.NewLine);
            handShakeSB.Append("Connection: Upgrade" + Environment.NewLine);

            string connectionOrigin =
                LoadConnectionOriginFromHandShake(stringHandShakeRequest);
            handShakeSB.Append("Sec-WebSocket-Origin: " +
                               connectionOrigin + Environment.NewLine);

            handShakeSB.Append("Sec-WebSocket-Location: "
                              + _location + Environment.NewLine);
            handShakeSB.Append(Environment.NewLine);

            byte[] handShakeResponsePart1 =
                Encoding.UTF8.GetBytes(handShakeSB.ToString());
            byte[] handShakeChallengeResponse =
                BuildChallengeResponse(stringHandShakeRequest, last8Bytes);

            byte[] handshakeResponse = new byte[handShakeResponsePart1.Length +
                                            handShakeChallengeResponse.Length];
            Array.Copy(handShakeResponsePart1,
                       handshakeResponse, handShakeResponsePart1.Length);
            Array.Copy(handShakeChallengeResponse, 0, handshakeResponse,
                       handShakeResponsePart1.Length,
                       handShakeChallengeResponse.Length);

            Console.WriteLine("Enviando resposta de handshake...");
            //Envia resposta para o cliente
            int a = _socketClient.Send(handshakeResponse, 0,
                    handshakeResponse.Length, 0);

        }

        /// <summary>
        /// Gera a resposta a partir da duas chaves e dos ultimos 8 bytes
        /// do handshake
        /// </summary>
        /// <param name="stringHandShakeRequest">Parte inicial
        ///                                      do handshake</param>
        /// <param name="last8Bytes">Ultimos 8 bytes que compoem
        ///                          o handshake</param>
        /// <returns>A resposta</returns>
        private byte[] BuildChallengeResponse(string stringHandShakeRequest,
                                              byte[] last8Bytes)
        {
            byte[] keyResult1 = null;
            byte[] keyResult2 = null;

            string[] handShakeTextLines = stringHandShakeRequest.Split(
                new string[] { Environment.NewLine },
                System.StringSplitOptions.RemoveEmptyEntries);

            foreach (string line in handShakeTextLines)
            {
                if (line.Contains("Sec-WebSocket-Key1:"))
                {
                    keyResult1 = getKeyResult(line.Substring(line.IndexOf(":")
                          + 2));
                }
                else if (line.Contains("Sec-WebSocket-Key2:"))
                {
                    keyResult2 = getKeyResult(line.Substring(line.IndexOf(":")
                        + 2));
                }
            }

            byte[] challengeResponse = BuildMD5ChallengeResponse(keyResult1,
                keyResult2, last8Bytes);

            return challengeResponse;
        }

        /// <summary>
        /// Gera um pedaco da resposta final baseado na chave passada como
        /// parametro seguindo as especiicacoes de
        /// http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
        /// </summary>
        /// <param name="originalKey">Uma chave</param>
        /// <returns>Um numero no formato big-endian 32-bit(byte mais
        ///          significativo armazenado primeiro)</returns>
        private byte[] getKeyResult(string originalKey)
        {
            byte[] resultKey = null;
            StringBuilder keyNumbers = new StringBuilder();
            int whiteSpacesCount = 0;

            foreach (char c in originalKey.ToCharArray())
            {
                //peque os digitos da chave e concatene gerando um numero
                if (char.IsDigit(c))
                {
                    keyNumbers.Append(c);

                }//conte quantos espacos em branco existem
                else if (char.IsWhiteSpace(c))
                {
                    whiteSpacesCount++;
                }
            }

            //Divida o numero gerado pela quantidade de espaços em branco
            int numericResult = (int)(Convert.ToInt64(keyNumbers.ToString()) /
                                 whiteSpacesCount);

            resultKey = BitConverter.GetBytes(numericResult);

            //garanta que esta como big-endian
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(resultKey);
            }

            return resultKey;
        }

        /// <summary>
        /// Constroi a resposta em md5 de key1 + key2 + key3
        /// 4 bytes big endian key1 + 4 bytes big endian key2 + 8 bytes key3.
        /// </summary>
        /// <param name="key1">4 bytes big endian key1</param>
        /// <param name="key2">4 bytes big endian key2</param>
        /// <param name="last8Bytes">8 bytes key3</param>
        /// <returns>16 bytes md5 de key1 + key2 + key3</returns>
        private byte[] BuildMD5ChallengeResponse(byte[] key1, byte[] key2,
                                                 byte[] last8Bytes)
        {
            byte[] challengeResponse = null;
            byte[] challengeArray = new byte[16];

            Array.Copy(key1, 0, challengeArray, 0, 4);
            Array.Copy(key2, 0, challengeArray, 4, 4);
            Array.Copy(last8Bytes, 0, challengeArray, 8, 8);

            MD5 md5Gen = MD5.Create();
            challengeResponse = md5Gen.ComputeHash(challengeArray);

            return challengeResponse;
        }

        /// <summary>
        /// Pega a origin do handshake
        /// </summary>
        /// <param name="stringHandShakeRequest">Handshake</param>
        /// <returns>Origin</returns>
        private string LoadConnectionOriginFromHandShake(
                                                 string stringHandShakeRequest)
        {
            string connectionOrigin = null;

            string[] handShakeTextLines = stringHandShakeRequest.Split(
                new string[] { Environment.NewLine },
                System.StringSplitOptions.RemoveEmptyEntries);

            foreach (string line in handShakeTextLines)
            {
                if (line.Contains("Origin:"))
                {
                    connectionOrigin = line.Substring(line.IndexOf(":") + 2);
                }
            }

            return connectionOrigin;
        }
    }
        #endregion
}

WebSocketClient.htm

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>

    <title>Web socket client test</title>

    <script type="text/javascript">

        var wsClient;

        //Verifica se o browser da suporte a websockets,
        //mas nao verifica versao do protocolo
        function WebSocketTest() {
            if (!("WebSocket" in window)) {
                alert("Este browser não suporta websockets!");
            }
        };

        //realiza a conexao
        function Connect() {

            try {

                //cria cliente websocket
                wsClient =
                   new WebSocket(document.getElementById("txtConnect").value);

                document.getElementById("txtConnect").disabled = true;
                document.getElementById("btnConnect").disabled = true;

                //cadastra eventos

                //chamado ao realizar a conexao com sucesso
                wsClient.onopen = OnOpen;
                //chamado quando o servidor manda mensagens para o cliente
                wsClient.onmessage = OnMessage;
                //chamado em caso de fechamento de conexao
                wsClient.onclose = OnClose;
                //chamado em caso de erro
                wsClient.onerror = OnError;

            } catch (ex) {
                alert(ex);
            }
        };

        //envia mensagem para o servidor
        function Send() {

            wsClient.send(document.getElementById("txtSend").value);

            document.getElementById("txtSend").value = "";
        };

        //fecha conexao com servidor
        function Close() {

            try {

                wsClient.close();

            } catch (ex) {
                alert(ex);
            }
        };

        function OnOpen() {
            alert("Conexão realizada com sucesso!");
        };

        function OnMessage(evt) {
            alert("Mensagem recebida: \"" + evt.data + "\"");

        };

        function OnClose() {
            alert("Conexão fechada!");
        };

        function OnError() {
            alert("Erro!");
        };

    </script>

</head>
<body onload="WebSocketTest()">
    <form>
                                        <!--Substuir "SEU_IP_AQUI" pelo ip
                               que foi configurado no .config do servidor-->
    <input id="txtConnect" type="text" value="ws://SEU_IP_AQUI:8181/ts" />

    <input id="btnConnect" type="button" value="Connect" onclick="Connect()" />
    <br />
    <input id="txtSend" type="text" />
    <input id="btnSend" type="button" value="Send" onclick="Send()" />
    <input id="btnClose" type="button" value="Close" onclick="Close()" />
    </form>
</body>
</html>

Considerações finais

Websocket parece ser uma tecnologia promissora. Vale ressaltar que o w3c pretende finalizar a normalização do html5 até 2014 e acontecerão melhorias até lá. O protocolo usado pelo websocket provavelmente ainda passará por algumas mudanças para melhorar, por exemplo, questões relacionadas à segurança.

Seguem alguns links interessantes:

• Especificação da API: http://dev.w3.org/html5/websockets/
• Versão do protocolo utilizada no exemplo: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
• Versão do protocolo mais atual: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-06
• Site com tabelas que indicam o suporte a tecnologias como HTML5, CSS3, SVG: http://caniuse.com/
• Texto falando sobre algumas vantagens no uso de websockets: http://websocket.org/quantum.html
• Tutorial introdutório sobre websockets: http://www.html5rocks.com/tutorials/websockets/basics/
• Demos do HTML5 em geral: http://html5demos.com/

.