A Mobits acabou de desenvolver um aplicativo que consulta e armazena informações de veículos e condutores em conjunto com a Kognitus, empresa incubada na COPPE/UFRJ. O aplicativo exibe também as restrições dos veículos e condutores, como excesso de pontos na carteira de habilitação, IPVA não pago, etc. Além disso, auxilia os fiscais de trânsito exibindo as ações que devem ser tomadas para cada tipo de restrição encontrada, guardando essas consultas com a posição GPS e foto para futuras auditorias.

Para consultar os veículos, o aplicativo é dotado de um módulo de reconhecimento de placas, capaz de identificá-las tirando uma foto, sem a necessidade de digitação.

O módulo de reconhecimento de placas foi desenvolvido pela Kognitus com tecnologia própria. Coube à Mobits o desenvolvimento do aplicativo mobile e do servidor web de comunicação, este último desenvolvido em Ruby on Rails.

O aplicativo foi financiado pela FAPERJ e futuramente será apresentado para órgãos como o DETRAN.

Com o lançamento do Windows Phone 7, a Microsoft resolveu romper com o passado descontinuando o antigo Windows Mobile. Ainda não se sabe sobre como serão as funcionalidades finais do novo sistema, mas as minhas maiores dúvidas são: como será a plataforma de desenvolvimento? Será que o novo sistema rodará os aplicativos de Windows Mobile? Se não, como migrá-los?

O que sabemos é que o Kernel do novo sistema é o Windows CE 6.0, uma evolução do Kernel do Windows Mobile que usava o Windows CE 5.0. O que mudou muito foi a interface, que foi totalmente remodelada para ficar mais finger-friendly e parecida com a do Zune HD para fazer frente com a interface do iPhone e demais concorrentes. Além disso ela também não poderá ser mais customizada por cada fabricante ou operadora.

Sobre os aplicativos do Windows Phone, a Microsoft deixou claro que os detalhes só seriam revelados futuramente. Contudo ela já revelou que os jogos poderão ter integração com a plataforma do Xbox LIVE e que o sistema terá um Marketplace, que pelo layout pareceu mais parecido com o do Zune do que com o Marketplace do Windows Mobile.

Segundo rumores do Engadget a nova plataforma não deverá rodar os antigos aplicativos diretamente, nem deve permitir atualização dos antigos dispositivos Windows Mobile para o novo sistema, o que é muito ruim para os desenvolvedores que terão que migrar o seus aplicativos para a nova plataforma e para os usuários finais. É realmente um novo sistema..

Os desenvolvedores já estão especulando sobre a plataforma de aplicativos e ferramentas. A expectativa é que o novo sistema seja baseado em 3 tipos de plataformas já existentes da Microsoft - o Silverlight para interfaces gráficas ricas, animações, etc; o XNA para desenvolvimentos de jogos, como no Zune e o Compact Framework usado no Windows Mobile para aplicações com formulário e componentes visuais diversos. Outra suposição é que as restrições do sistema para chamadas de APIs privadas aumentarão bastante, impedindo que os aplicativos tenham acesso direto a diversos recursos como tinham no sistema antigo. A plataforma de desenvolvimento deve ser o Visual Studio 2010 em conjunto com o Express Blend e o Windows Phone emulator a ser revelado.

Todas as dúvidas, contudo, só serão esclarecidas mesmo no evento MIX10, de 15 a 17 de março, onde a Microsoft ficou de revelar mais detalhes para a comunidade de desenvolvedores.

Só nos resta aguardar pelas notícias e torcer para que a Microsoft, desta vez, desenvolva um sistema que não seja descontinuado e permita que, tanto os aparelhos quanto os aplicativos antigos, possam ser migrados sem muito custo para as versões subseqüentes.

Leia também:

• Interfaces mais atraentes no Windows Mobile
• Mobits desenvolve mais um aplicativo em Windows Mobile
• Agendamento de programas em Windows Mobile

Criar interfaces bonitas para Windows Mobile é um grande desafio, já que os componentes são um tanto limitados e a API não permite, por exemplo, o uso de imagens com transparência, label multi-line, ou até mesmo o efeito gradiente como background de algum componente. Então para fazer algo mais personalizado, é preciso criar ou modificar os componentes existentes e nem sempre isso é uma tarefa fácil.

Como tempo é dinheiro, muitas vezes modificar ou criar cada componente pode levar bastante tempo. Logo, seria interessante utilizar componentes prontos para facilitar a vida. Foi assim que descobri a Resco.net, uma empresa lá da Eslováquia que trabalha no desenvolvimento de soluções para Windows Mobile. Além de fazer aplicações e jogos, ela também desenvolve componentes para o WinMo: o Mobile Forms Toolkit. O toolkit oferece uma série de componentes, como listas, tabelas, abas, combo-box, e muitos outros, que podem ser personalizados de diversas maneiras: troca de cores, fundo gradiente, imagens, orientação e por aí vai. Além disso, ele é totalmente integrado ao Visual Studio.

A Resco disponibiliza uma versão trial que dura 30 dias. Para ter a versão paga, é preciso assinar um de seus planos. A licença é anual e cobre futuras atualizações, novos componentes e suporte. Para ver as singularidades e preços de cada plano, veja aqui.

Aqui na Mobits, baixamos a versão trial e podemos dizer que a ferramenta cumpre muito bem o que promete. Vale muito a pena! :)

Ah! Se você conhece alguma outra ferramenta semelhante, comente!

Quem já programou para iPhone conhece as facilidades que o Interface Builder fornece para fazer as suas telas. Para quem tem a árdua missão de elaborar as mesmas interfaces para Windows Mobile, não vai encontrar todas essas facilidades, o que pode prejudicar e muito o desenvolvimento e, consequentemente, a experiência do usuário.

Para exemplificar o que digo, mostro a vocês um problema que tive em Windows Mobile, que na teoria deveria ser bem fácil resolver: uma label que pode receber conteúdo dinâmico (acontece toda hora) e que o seu container deve ser redimensionado de acordo com esse conteúdo; se ele tiver que ter duas linhas, que aumente o seu tamanho para comportar duas. Se tiver três, que aumente mais um pouco.

Isso deveria ser tranquilo, certo? Errado. Ao pesquisar sobre como fazer isso, até descobri que há como fazer em C#, utilizando o método Graphics.MeasureString; porém, como muitas funcionalidades que a gente acha fuçando no Google, essa é mais uma que não está disponível para o Compact Framework.

Com o desânimo já batendo à porta, achamos em um dos últimos links procurados um site na Argentina de um desenvolvedor que implementou uma classe para tratar disso em Windows Mobile. Como sempre, pegamos a implementação dele, incorporamos ao nosso código, e colocamos de maneira mais fácil de ser utilizada.

Primeiro, baixe esse arquivo, que contém a definição da classe que iremos utilizar. Ela contém o código que faz toda a mágica. Chamo a atenção para o seguinte método:

internal static int GetLabelSize(Label label, Graphics graphics) {
    return CFMeasureString.MeasureString(graphics, label.Text, label.ClientRectangle, false).Height;
}

Com ele, basta você passar a label que você deseja saber a altura (height), usando o seguinte código:

minhaLabel.Height = CFMeasureString.GetLabelSize(minhaLabel, CreateGraphics());

O método CreateGraphics() é interno a um Form, de forma que a utilização da linha acima deve ser feita preferencialmente no formulário. Convém dizer que o GetLabelSize não funciona com todas as implementações de Label, como, por exemplo, o transparent label. Mas já quebra o maior galho :P.

Leia também:

• Programando para Windows Mobile usando MVC e Delegates - Parte 1
• Programando para Windows Mobile usando MVC e Delegates - Parte 2
• Label transparente em Windows Mobile

Caros, por conta de um projeto nosso em desenvolvimento para Windows Mobile, tivemos que aprender como fazer agendamento de um programa, em background, a ser executado em uma hora específica.

Esse agendamento pode ser extremamente útil para o caso de você estar implementando um despertador, ou algo que de tempos em tempos verifique um estado para saber se o usuário deve ser notificado ou não, ou até executar um outro programa paralelo ao seu, rodando em background, enquanto o seu roda em primeiro plano. Neste link há um vídeo explicando como fazer. Se você não está muito a fim de assistir o vídeo em inglês, pode acompanhar por aqui.

Primeiro, baixe este arquivo e adicione ele ao seu projeto. Veja o que ele tem:

public class Scheduler {
    [DllImport("CoreDLL.dll")]
    public static extern int CeRunAppAtTime(string application, SystemTime startTime);

    [DllImport("CoreDLL.dll")]
    public static extern int FileTimeToSystemTime(ref long lpFileTime, SystemTime lpSystemTime);

    [DllImport("CoreDLL.dll")]
    public static extern int FileTimeToLocalFileTime(ref long lpFileTime, ref long lpLocalFileTime);
}

Para você que não está habituado com código nativo importado através de DLL, temos três métodos nessa classe, sendo que o principal é o primeiro:

[DllImport("CoreDLL.dll")]
public static extern int CeRunAppAtTime(string application, SystemTime startTime);

Basta chamar esse método, passando para ele o endereço da aplicação e a data no formato SystemTime. Essa classe está declarada dentro do arquivo, dessa forma:

[StructLayout(LayoutKind.Sequential)]
public class SystemTime {
    public ushort wYear;
    public ushort wMonth;
    public ushort wDayOfWeek;
    public ushort wDay;
    public ushort wHour;
    public ushort wMinute;
    public ushort wSecond;
    public ushort wMilliseconds;
}

Isso explica os outros métodos auxiliares da classe Scheduler. Ambos são usados para traduzir a data de DateTime para SystemTime. Mas, se você estiver utilizando nosso código, vai ver que há mais um método:

public static void AgendarDownload(string aplicativo, DateTime quando) {
    long fileStartTime = quando.ToFileTime();
    //convertendo de DateTime para SystemTime
    long localFileStartTime = 0;
    Scheduler.FileTimeToLocalFileTime(ref fileStartTime, ref localFileStartTime);
    SystemTime systemStartTime = new SystemTime();
    Scheduler.FileTimeToSystemTime(ref localFileStartTime, systemStartTime);

    //chamando o método nativo
    Scheduler.CeRunAppAtTime(aplicativo, systemStartTime);
}

E pronto! Com esse método estático, você pode chamar o Scheduler. Veja o exemplo abaixo, onde eu chamo o IE para ser executado cinco minutos depois:

static void Main(string[] args) {
        DateTime dataAgendamento = DateTime.Now + new TimeSpan(0, 5, 0);
        Scheduler.AgendarDownload(@"\Windows\iexplore.exe", dataAgendamento);
}

Em nossos testes, o código funcionou perfeitamente, tanto no Windows Mobile Professional quanto no Standard (se você não sabe a diferença entre eles, veja neste link). Testamos agendar para um horário em que o aparelho estivesse desligado, e o programa rodou assim que o Windows foi iniciado. Lembre-se que o aplicativo não tem nenhuma ligação com o que o agendou inicialmente; isso significa que se este for fechado, não influenciará na execução daquele.

Continuando o post sobre a utilização de MVC em um projeto para Windows Mobile no Visual Studio 2008, falaremos agora como lançar mão dos eventos para poder completar o padrão.

De acordo com algumas literaturas, a implementação do padrão MVC especifica que o modelo notifique a view em caso de alterações, de forma que os dados exibidos na view sejam atualizados.

Para fazer essa notificação, vamos ampliar um pouco mais o conceito de delegates, passado no primeiro post, e utilizar também eventos.

Na verdade, para os mais atentos, o conceito de evento já foi utilizado no post anterior, quando eu criei o seguinte método na view para adicionar um delegate:

public void AddSalvarClick(ViewEventsDelegate metodo) {
    BtnSalvar.Click += new EventHandler(metodo);
}

Estávamos na verdade dizendo que o evento Click do botão BtnSalvar iria acionar o método passado por ele por parâmetro. Assim, fica mais fácil entender o funcionamento de um evento:

• Os eventos são os "gatilhos" para os delegates: quando um evento é chamado, os métodos adicionados a ele são chamados;

• Os eventos não aceitam qualquer tipo de delegate: ao declarar um evento, você deve especificar qual o tipo de delegate está associado a ele. De uma forma direta, isso implica dizer que os eventos só aceitam os métodos com a assinatura especificada na declaração do delegate.

Voltemos ao nosso exemplo. Como disse acima, a implementação do padrão em camadas pede a notificação da view em caso de alteração no modelo. Mas aqui é necessário pensar um pouco na forma como essa notificação vai ser feita, principalmente no que diz respeito ao modo como a informação a ser alterada será passada para a view. Em alguns textos, ao notificar a view, o objeto de modelo passa como parâmetro ele mesmo, e a view pega então todos os valores do modelo e preenche. O problema que alguns podem ver aqui é o da acoplagem, pois eu estaria prendendo a classe view a um tipo específico de modelo. Uma solução alternativa seria criar notificações para várias alterações, passando então o valor (geralmente em tipos básicos como strings, inteiros, etc) só do que está sendo alterado.

Não sou puritano, mas acho as duas abordagens válidas. A vantagem da segunda - além da baixa acoplagem - é reduzir para métodos pequenos a alteração do conteúdo. Tenho certo medo de métodos do tipo AlteraTudo(object modelo), por ter séria tendência a se tornar um método frankenstein, difícil de dar manutenção.

Vamos ao código! Em um exemplo fictício, onde tenho um sistema de venda de livros, um modelo óbvio seria um Livro. Vou criar nesse exemplo um evento que trata a notificação da alteração do preço do livro. Quando o preço for alterado, ele notifica a todos aqueles que "assinaram" o evento.

  namespace PostMVC {
      //declarando o delegate
      public delegate void PriceChangeDelegate(float price);

      class Book {

          //criando o evento
          private event PriceChangeDelegate OnPriceChange;

          //metodo que adiciona delegates ao evento do preco
          public void AddPriceChangeDelegate(PriceChangeDelegate priceDelegate) {
              OnPriceChange += priceDelegate;
          }

          //o atributo preco
          private float _price;

          // Get e Set do campo preço. Perceba que no set eu chamo o 
          //evento que sera executado por causa da alteracao feita
          public float Price {
              get { return _price; }
              set {
                  _price = value;
                  if (OnPriceChange != null)
                      OnPriceChange(value);
              }
          }
      }
  }

Percebam a validação feita antes de executar o evento:

  if (OnPriceChange != null)
        OnPriceChange(value);

Um evento é nulo se nenhum delegate está associado a ele. Agora, na view, o código fica bem simples: basta adicionar um método que tenha a assinatura do delegate especificada, que faça essa alteração:

  public void AlteraPrecoNaTela(float preco) {
        //codigo que escreve na tela
  }

E no construtor também fica bem tranquila a implementação:

  class BookController {
        private Book model;
        private BookPriceForm view;

        //construtor
        BookController() {
              model = new Book();
              view = new BookPriceForm();

              model.AddPriceChangeDelegate(view.AlteraPrecoNaTela);
        }
  }

Com isso, o único que fica acoplado é o controller, que é quem realmente tem que ter os modelos e as vistas.

Dessa forma, você evita colocar o código todo no formulário, você traz a sua lógica de negócio para o controlador, seu código fica mais simples, mais fácil dar manutenção, e todos ficam felizes! :)

Leia também:

• Programando para Windows Mobile usando MVC e Delegates - Parte 1
• Label transparente em Windows Mobile
• Mobits desenvolve mais um aplicativo em Windows Mobile

Não há nada que mais tire um desenvolvedor de sua zona de conforto do que começar a programar em outra linguagem. A história é sempre a mesma: novos paradigmas, aprender sintaxe nova, utilizar uma IDE diferente do que você está acostumado, fazer a velha comparação entre a nova e a velha (e a eterna pergunta qual é a melhor linguagem sempre surge), enfim, sempre há uma porção de dificuldades implícitas à mudança.

Por conta de um projeto para a UFRJ em Windows Mobile da Mobits, comecei a desenvolver em C# utilizando o Visual Studio 2008. Fora as dificuldades iniciais, um dos pontos mais críticos, utilizando o Visual Studio, foi quando nós tentamos seguir o padrão de projetos MVC.

Eu explico. Quando você utiliza o Visual Studio (principalmente para quem já programou nele anos atrás fazendo aplicativos para VB6), a tentação de colocar todo o seu código dentro das views (os formulários) é muito grande. Está tudo ali dentro, prontinho, basta clicar duas vezes no botão e já começar a codificar.

Mas aí é que reside o problema. Não vou gastar esse post relatando as vantagens de se programar seguindo os padrões de projeto, você encontra textos melhores aqui. Por acreditar que em projetos sérios eles valem a pena ser seguidos, comecei a fuçar vários lugares para descobrir como poderia lançar mão do padrão. Pesquisando, achei quais seriam as técnicas que serviriam para os meus propósitos: os eventos e os delegates.

Nesse primeiro post, eu vou falar um pouco sobre como utilizar os delegates para esse propósito. Em um segundo post, vou tentar explicar como funcionam os eventos e mostrar sua utilização para nossos propósitos.

Delegates

Não há na internet (ou pelo menos eu não procurei direito) um lugar que tenha uma explicação simples de como eles funcionam ou de como utilizá-los. Vamos ver se eu consigo de maneira simples e objetiva.

Os delegates, de um modo simples, são métodos com uma assinatura padrão estipulada na criação e são utilizados no tratamento de métodos e eventos. Eu não me preocupo como um resultado vai ser tratado, então eu delego a um outro objeto o tratamento desse resultado.

Dada essa definição formal, você tem que decidir como utilizar os delegates em seu projeto orientado a camadas. Uma opção seria utilizá-los em praticamente tudo, inclusive na utilização dos tratamento dos eventos da view. Todos os comandos seriam realizados no controller, acessados através dos delegates públicos criados na view.

Na view, eu tenho que criar os delegates que irão tratar os eventos. Para isso, eu tenho primeiro que declarar como será a assinatura dele:

public delegate void ViewEventsDelegate(object args, EventArgs e);

Com essa declaração, eu posso passar um método como parâmetro, desde que o método em questão também possua a assinatura especificada. Imaginando que temos um botão de salvar com nome BtnSalvar, e queremos associar um método para ser executado quando for acionado o evento Click, basta fazer:

public void AddSalvarClick(ViewEventsDelegate metodo) {
    BtnSalvar.Click += new EventHandler(metodo);
}

A vantagem dessa abordagem é que eu posso adicionar não só um método, mas vários para serem executados no mesmo evento. Não que eu tenha achado uma utilidade para isso, mas quem sabe um dia a gente venha precisar! :-)

Com a implementação feita no lado da view, basta que no controller eu diga quem irá implementar o evento. No nosso exemplo, suponha que a view seja ViewAmostras. No corpo do controller teremos:

public class Controller {
    ViewAmostras view; // tela que exibe as amostras

    //construtor
    public Controller() {
        view = new ViewAmostras();
        //sem a assinatura
        view.AddSalvarClick(this.Salvar); 
    }

    void Salvar(object sender, EventArgs e) {
        //implementacao do método de salvar
    }
}

Esta maneira de implementar tem seus prós e contras. Muitos podem considerar esse modo mais burocrático, ou complexo demais. Para os que zelam por Orientação a Objeto, essa é a forma mais correta, por diminuir o acoplamento entre as classes.

Independente do modo, o ideal é que, se o seu desejo é fazer um projeto utilizando MVC, fuja da tentação de fazer todo o código dentro do formulário. Nós já tivemos uma experiência de refatoração aqui na Mobits, e que foi muito tranquila justamente por estar separado em camadas.

No próximo post vou falar sobre os eventos, utilizando eles para notificar as alterações feitas no modelo.

Leia também:

• Label transparente em Windows Mobile
• Mobits desenvolve mais um aplicativo em Windows Mobile
• Mobits desenvolve sistema para rastrear as ambulâncias do Samu

Uma das dificuldades encontradas por quase todos que se aventuram a programar em Windows Mobile é: Como fazer Label com fundo transparente? E porque a propriedade transparent parece não funcionar?

Começando pela segunda pergunta, a resposta é que a propriedade transparent faz com que Label herde a cor de seu pai, o que funciona somente quando temos Label colocada sobre um fundo de uma única cor. Ou seja, essa propriedade de nada adianta se temos uma imagem de fundo. Então como solução (e também respondendo a primeira pergunta), siga os passos abaixo.

Primeiro, crie em seu projeto uma Component Class (neste exemplo criamos uma nova pasta chamada de Util -> Add -> New Item -> Component Class).

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.Drawing;

namespace TransparenteLabelExample.Util {
    public partial class TransparentLabel : Control {
        public TransparentLabel() {
            this.TextChanged += new System.EventHandler(this.alterouTexto);
        }

        public void alterouTexto(object sender, EventArgs e) {
            this.Invalidate();
        }

        protected override void OnPaintBackground(PaintEventArgs e) {
        }

        private bool bPaintOnce = false;

        protected override void OnPaint(PaintEventArgs e) {
            if (!bPaintOnce) {
                bPaintOnce = true;
                this.Visible = false;
                this.Parent.Invalidate(this.Bounds);
                this.Parent.Update();
                this.Visible = true;
                return;
            }
            else {
                bPaintOnce = false;
                Graphics g = e.Graphics;
                Font font = this.Font;
                SolidBrush brush = new SolidBrush(this.ForeColor);
                g.DrawString(this.Text, font, brush, 1, 1);
                g.Dispose();
            }
        }
    }
}

Depois, execute seu programa uma vez, a Toolbox do Visual Studio conterá um novo Componente que é a TransparentLabel!

Aqui uma imagem para ilustrar:

Também é possível utilizar esta mesma técnica para criar imagens com fundo transparente com esta Classe.

Através de um convênio entre UFRJ e a Petrobras, a Mobits foi contratada para desenvolver um aplicativo móvel que auxiliasse no controle das amostras coletadas para análise dos laboratórios da Petrobrás.

A aplicação, desenvolvida para Windows Mobile, permite aos laboratórios acompanharem o trâmite das amostras coletadas nas plataformas até os laboratórios. Com dispositivos móveis dotados do programa em todas as etapas da cadeia, os usuários podem informar onde se encontra uma determinada amostra, bem como para onde ela está sendo levada, e se houve algum problema no armazenamento ou transporte da mesma.

O aplicativo também auxilia na tomada de decisão em caso de problemas com as amostras coletadas: nele, o usuário encontra todas as informações de normas, procedimentos e recomendações a serem seguidas durante todo o processo. Junto a isso, o usuário preenche um checklist de verificação do estado da amostra, visando assegurar sua qualidade em todas as etapas da cadeia.

Nesse projeto também foram utilizados leitores de código de barras e RFID nos dispositivos, para permitir maior rapidez na entrada de dados para o dispositivo, além de diminuir os erros manuais de digitação. Caso sejam encontradas evidências que precisem de fotos, elas podem ser coletadas através do dispositivo, algo já realizado no projeto desenvolvido para a Modulo.

A Mobits foi contratada por um convênio entre a UFRJ e a FAPERJ para desenvolver um sistema que rastreará as ambulâncias do Samu do Rio de Janeiro. O sistema se trata de um aplicativo na tecnologia Windows Mobile que terá suporte a GPS e enviará as suas coordenadas, por redes GSM, para as centrais do Samu. Além das coordenadas, o sistema também enviará e receberá diversas informações como as ocorrências, o estado delas e informações relevantes para o tratamento das emergências.

O sistema móvel desenvolvido pela Mobits se comunicará com o Sismove, desenvolvido no NCE/UFRJ, que ficará nas centrais do Samu.

Com o aplicativo móvel, as centrais do Samu poderão saber onde estão as ambulâncias e verificar se estão disponíveis, o que facilitará no tratamento de emergências o mais rápido possível. Além disso, as ambulâncias também poderão receber pelo celular as ocorrências e visualizá-las no mapa, agilizando o atendimento.

Meus amigos, eu tenho um HTC Touch Cruise e baixei a pouco tempo a versão 6.1 do Windows Mobile. Com uns dois meses de uso, já dá para ter algumas impressões sobre o sistema operacional da Microsoft.

Como todos sabem, a Microsoft perdeu bastante terreno (pelo menos na mídia) para os atuais queridinhos do mercado (leia-se iPhone e Android). É lógico que o sistema operacional de Steve Balmer vai correr atrás para tentar se reposicionar no mercado. Ainda existem muitos celulares que rodam Windows Mobile e a lista de programas existentes é bem diversa. Mas a aposta da Microsoft em ainda utilizar a Stylus foi um tiro muito errado. Ainda bem que tenho observado que muitos programadores tentam ao máximo fazer com que seus programas dependam o mínimo possível da canetinha.

No meu caso, eu ja me acostumei a não utilizar a stylus. Aí é que entra a minha avaliação sobre a nova versão do Windows Mobile. Tenho lido a respeito das notícias de que a nova versão (a 7, é verdade) seria o mais finger friendly possível. Pois bem, quão grande foi a minha decepção ao perceber que praticamente nada dessas melhorias estão presentes nessa nova versão disponível. Digo isso porque a única coisa perceptível ao usuário é o aumento do botão de fechar um programa, no canto superior esquerdo da tela. Continua pequeno, mas qualquer melhoria é sempre bem-vinda.

Outra mudança está relacionada à organização das mensagens de texto (SMS): agora elas estão agrupadas como no Gmail, onde as "conversas" com um mesmo contato são agrupadas, assim você consegue acompanhar o histórico das mensagens. Confesso que, ao utilizar meu aparelho, essas foram as únicas mudanças perceptíveis pra mim. No site da Microsoft aparecem outras vantagens, tais como melhoria no wifi. Conversando com outras pessoas que têm a versão 6.0, percebi que realmente houve melhorias, a conexão agora têm sido mais estável.

Pois bem, se você chegou até aqui e está pensando: "Só isso?", foi exatamente o que eu pensei. É pouco pra quem está tendo que correr atrás de um mercado onde se está em desvantagem, e pra quem vem adiando o lançamento da nova versão definitiva. Ainda bem que já me informei com a HTC e que essa versão estará disponivel para os usuários do celular, gratuitamente. É esperar pra ver.

E você? Utiliza Windows Mobile? Quais são suas impressões? O que você mais gosta? O que mais te irrita? Quais são os melhores programas? Vamos trocar figurinhas nos comentários! Manda aí.

  A Apple decretou, no dia primeiro de outubro, o fim do NDA, um acordo que impedia que os desenvolvedores de softwares para iPhone pudessem divulgar conteúdos técnicos relacionados ao desenvolvimento para o aparelho. Com o fim desta barreira, os desenvolvedores e experts já podem compartilhar o que sabem com os demais! Livros já estão sendo lançados e os blogs sobre este assunto já não estão mais burlando a Apple :P.

  A Mobits decidiu que irá também compartilhar o seu conhecimento sobre este e outros assuntos relacionados ao desenvolvimento de softwares para o iPhone e outras plataformas para dispositívos móveis, como o JavaME, Android, Windows Mobile e Symbian. Estamos lançando uma nova seção em nosso site, chamada Blog técnico. Fiquem atentos!