Uma das funcionalidade que mais me foi útil no Adobe AIR, foi a adição de uma API mais bem elaborada para fazer atualização automatica de meus aplicativos. Isso pode ser muito importante porque nem todos os usuários tem tempo(ou vontade) de voltar no site do aplicativo para baixar a última versão.
Isso já é rotina para sistemas operacionais e softwares que usamos no dia-a-dia como o Mozilla Firefox e o Google Chrome(que nem pede permissão para atualizar né senhor Google).

A partir do Adobe AIR 1.5, temos a classe ApplicationUpdater e ApplicationUpdaterUI que tem como objetivo, definir o básico de funcionalidade de atualização para os aplicativos feitos com Adobe AIR

Gerenciar as atualizações pode ser complicado e o AIR update framework possui as API’s necessarias para que você faça isso de maneira prática e funcional. O desenvolvedor pode por exemplo:

• Verificar atualizações por intervalo de tempo ou por requisição do usuário.
• Baixar os arquivos de atualização da web
• Avisar o usuário na primeira execução do software recém-instalado
• Confirmar se o usuário deseja verificar se há atualizações
• Exibir informações sobre a nova versão de atualização para o usuário
• Exibir o status do download ou informação de erro para o usuário

As informações são obtidas a partir de arquivos XML onde você diz qual a última versão do software, as novidades da nova versão etc. Vamos a um exemplo prático, no caso usarei o Flash Builder que já deve ter os arquivos applicationupdater.swc e applicationupdater_ui.swc como referencia na biblioteca.
Começamos pelo xml chamado updateConfig.xml, que “dira” a seu aplicativo onde estão os arquivos para atualização.

Ele deve ser salvo no mesmo diretorio da sua aplicação, junto com os outros arquivos xml e swf. Agora no Flex, instanciaremos a classe ApplicationUpdateUI e setaremos o arquivo xml de configuração para que o Flex possa saber onde está a atualização.

O arquivo updateDescriptor.xml é onde fica setado a versão em si da atualização do seu aplicativo e onde você pode colocar a descrição das novidades da atualização.

Basicamente é isso, vamos só implementar a chamada para que ao abrir o aplicativo, ele verifique se existe atualização.

Criei uma segunda versão do meu aplicativo de teste para demonstração, deveremos ter o seguinte resultado:

Clique para ampliar

Caso o usuário queira verificar se existe alguma atualização do aplicativos, basta clicar no botão “check for upadates. O arquivo atualizado é baixado e instalado.

Clique para ampliar

Clique para ampliar

Clique para ampliar

Referências:
http://help.adobe.com/en_US/air/build/WS9CD40F06-4DD7-4230-B56A-88AA27541A1E.html
http://www.adobe.com/devnet/air/flex/quickstart/articles/update_framework.html

Veja também:

• No Related Post

Ontem eu vi uma pergunta no fórum de Silverlight do MSDN sobre como achar todos os campos TextBox que existem dentro de uma ChildWindow. Já havia algumas respostas para a pergunta mas elas eram bem pontuais para aquele problema específico e necessitavam de várias suposições sobre a estrutura da aplicação para funcionar sem problemas (por exemplo, saber quais tipos de Panel estão sendo usados). Alguns anos atrás, quando eu comecei a fazer uma das minhas primeiras behaviors para publicar na galeria do Expression Blend, eu descobri uma classe do Silverlight (também existe no WPF) que serve justamente para permitir navergarmos na árvore visual de uma aplicação, tanto procurando controles filhos quanto pais de um determinado controle.

A behavior em questão é a que permitia que se fizesse scroll com a wheel do mouse (a rodinha) em controles que apresentassem scrollbar para aplicações feitas em Silverlight 3. Hoje essa behavior praticamente não é mais necessárias pois o Silverlight 4 já implementa esse comportamento nativamente, mas não era esse o caso na época. Para poder implementar essa função eu precisei criar um código que fosse capaz de ler toda a hierarquia visual do controle (vasculhando todos os componentes do qual o template do controle era composto), procurando por algum ScrollViewer. Se eu o encontrasse, a behavior assinava os eventos necessários do controle para que o scroll funcionasse como esperado.

Para navegar pela árvore visual, a classe que utilizei foi a VisualTreeHelper. Voltando ? dúvida do fórum, eu decidi criar um método genérico que fosse capaz de encontrar todos os controles de um determinado tipo em uma hierárquia utilizando essa classe, assim estaria garantindo que não precisaria ficar colocando “if”s para cada tipo de painel diferente que aparecesse na minha frente. Sem mais delongas, segue abaixo o método que eu fiz.

public static T[] SearchUIElements(UIElement root, int maxlevel = int.MaxValue, int level = 0)     where T : UIElement 

    var result = new List();

    if (root != null)         if (root is T)             result.Add(root as T);

        if (level < maxlevel)             var childrencount = VisualTreeHelper.GetChildrenCount(root);            DependencyObject child;            for (var i = 0; i < childrencount; i++)                 child = VisualTreeHelper.GetChild(root, i);                if (child is UIElement)                     result.AddRange(SearchUIElements(child as UIElement, maxlevel, level + 1));

            }        }    }

    return result.ToArray();}

Como vocês podem ver o método não é grande e é bem simples. Ele aceita 3 parâmetros:

• root: controle raiz a partir de onde será iniciada a busca. Por exemplo: LayoutRoot.
• maxlevel: número máximo de níveis que a busca irá “descer” nos descendentes. Este parâmetro é opcional e o seu valor padrão é int.MaxValue, garantindo que será lida a hierarquia inteira a partir do ponto inicial.
• level: nível atual da busca. Esse parâmetro é utilizado apenas pela própria função para controlar quando a busca atingirá o nível máximo solicitado pelo usuário.

A função é genérica. O parâmetro T serve para indicar qual tipo de controle será procurado, assim como permitir que o retorno sejá tipado corretamente. A é executada de forma recursiva, chamando a si mesma para cada novo ítem na hierarquia.

O resultado da função é sempre um array do tipo de controle solicitado. Esta função sempre retorna uma array, mesmo que seja vazio (não será retornado null).

Abaixo temos um xaml de exemplo e algumas chamada ? função com a descrição do que será encontrado em cada caso.

<Grid x:Name="LayoutRoot">    <TextBox />    <TextBox />    <Grid>        <TextBox />        <TextBox />        <Grid>            <TextBox />        Grid>    Grid>Grid>

//acha TODOS os 5 campos TextBox var textboxes = SearchUIElements<TextBox>(LayoutRoot);

//acha apenas os 2 campos TextBox de LayoutRoottextboxes = SearchUIElements<TextBox>(LayoutRoot, 1);

//acha 4. Os 2 acima e os 2 que estão no primeiro Grid filhotextboxes = SearchUIElements<TextBox>(LayoutRoot, 2);

//acha TODOS os Grids a partir de LayoutRoot, inclusive ele mesmo var grids = SearchUIElements<Grid>(LayoutRoot);         

Agora que eu já mostrei como faz, você acha que consegue fazer uma função semelhante que navegue ao contrário na hierárquia? (procurando nos pais de um controle até chegar na raíz da aplicação…). Fica o desafio.

Recentemente, conversando com alguns desenvolvedores no trabalho e verificando algumas perguntas publicadas nos fóruns do MSDN, eu notei que ainda há uma dificuldade muito grande tanto de compreensão quanto de implementação para trabalhar com métodos assincronos. Isso se torna um problema particularmente importante em aplicações Silverlight pois todas as chamadas a web services, RIA services, web requests, etc são obrigatoriamente feitos de forma assincrona, não havendo opções para executar essas mesmas operações da forma sincrona e linear ? qual a maioria dos desenvolvedores está acostumada.

Acontece que desenvolvimento assincrono não é difícil e, depois que você aprende e se acostuma, você acaba percebendo que suas aplicações passam a funcionar muito melhor. Sim, não vou argumentar aqui contra o fato de que é necessário se acostumar e que começo seja realmente algo estranho, mas posso garantir que demora pouco tempo para se acostumar e os benefícios são muitos.

Há muitas abordagens e estratégias possíveis para desenvolvimento assíncrono e eu vou apresentar aqui uma delas que é bem simples e que eu usei em praticamente todos os projetos Silverlight em dos quais participei. Essa abordagem não envolve o uso de nenhum framework ou biblioteca externa e pode ser utilizada tranquilamente também em projetos que não sejam Silverlight.

Digamos que você precisa obter o html de uma página web por algum motivo. Uma forma de fazer isso seria criando uma nova instância de WebClient, assinando o evento DownloadStringCompleted e depois chamando o método DownloadString passando a url. Ok, não é difícil, mas é um código repetitivo que poderia facilmente ser reaproveitado ao invés de ser copiado por toda sua aplicação em todo lugar onde você precisar fazer download de uma página. O que eu costumo fazer para esse tipo de chamada é criar um método estático em uma classe utilitária e simplesmente chamar esse método passando, nesse caso, minha url e um ponteiro de callback. É mais fácil mostrar:

public static void HttpGet(string url, Action<string, Exception> callback)     if (!string.IsNullOrWhiteSpace(url))         var client = new WebClient();        client.DownloadStringCompleted += (sender, e) =>             if (callback != null)                 callback(e.Result, e.Error);

        };        client.DownloadStringAsync(new Uri(url));    }}

Quais são as vantagens desse método:

• para executá-lo não é necessário instanciar nenhuma classe
• é facil de reutilizar
• permite que a lógica da minha aplicação fique um pouco mais simples, já que não me obriga a assinar nenhum evento no meu código

Para executar esse método, eu posso usar 2 abordagens.

Abordagem 1 – Delegar o retorno para outro método. Nessa abordagem eu chamo o método HttpGet passando a url desejada e o ponteiro de um método que será executado quando o request for concluído.

private void LoadData()     HttpGet("http://kelps.net", DataLoaded);

private void DataLoaded(string data, Exception error)     if (error == null)         //utiliza os dados retornados na variável "data"

}

Abordagem 2 – Utilizar uma expressão lambda para criar um método anônimo inline no meu código, ao invés de criar uma função separada apenas para processar os dados retornados.

HttpGet("http://twitter.com/kelps", (data, error) =>     if (error == null)         //utiliza os dados retornados na variável "data"

});

A única diferença de funcionamento entre as 2 abordagens acima é que na segunda seria possível utilizar variáveis que estiverem no mesmo escopo da chamada que está sendo feita, ao passo que na primeira seria necessário que essas variáveis fossem globais da classe para que isso funcione. Nos projetos em que trabalho eu costumo utilizar ambas as abordagens, de acordo com o que faz mais sentido em cada situação. Expressões lambda são bem concisas e compactas, mas são claras para qualquer desenvolvedor.

Este foi apenas um pequeno exemplo de como trabalhar com chamadas assincronas sem ficar se perdendo com assinaturas e liberação de eventos. Há outras formas mais complexas e robustas de lidar com isso mas a minha intenção hoje era simplesmente mostrar como dá pra trabalhar de forma simples com código assíncrono, mesmo sem utilizar nenhuma biblioteca externa.

Princ?pio da ?nica Responsabilidade:

“Nunca deve haver mais de um motivo para uma classe ser alterada”

Cada responsabilidade constitui-se uma dimens?o de mudan?as. Se uma classe tem mais de uma responsabilidade, ent?o haver? mais de uma raz?o para alter?-la. Quanto mais responsabilidades h? numa classe, mais fr?gil (maior risco de para de funcionar) torna-se o projeto.

Viola??o do princ?pio:

Considere a Classe TAD:

import java.util.Vector;

/**
 *
 * @author Edgard Davidson
 */
public class TAD 

    private Vector vector;

    public TAD()
        vector = new Vector();

    public void empilhar(Object element)
        vector.insertElementAt(element, 0);

    public Object desempilhar()
        if (!this.eVazia())
            Object result = vector.firstElement();
            vector.removeElementAt(0);
            return result;
         else
            return null;

    }

    public void enfileirar(Object element)
        vector.add(element);

    public Object desenfileirar()
        if (!this.eVazia())
            Object result = vector.firstElement();
            vector.removeElementAt(0);
            return result;
         else
            return null;

    }

    public int obtemTamanho()
        return vector.size();

    public boolean eVazia()
        return vector.isEmpty();

}

Como pode ser visto, a classe TAD (Tipo Abstrato de Dados) ? uma classe que possui mais de uma responsabilidade. Ela implementa o contrato de um Pilha com os m?todos (empilha e desempilha) e o contrato de uma Fila com os m?todos (enfileira e desenfileira). A classe TAD viola o princ?pio da ?nica responsabilidade. Para se adequar ao princ?pio, ? necess?rio aplicar a refatora??o Extrair Classe. Essa t?cnica de refatora??o ? a mais indicada para o caso da viola??o do SRP. Sempre que houver uma classe fazendo o trabalho que deveria ser feito por duas classes, aplique a referida refatora??o para criar uma nova classe movendo os campos e m?todos pertinentes da classe antiga para a classe nova.

Al?m de aplicar a refatora??o Extrair Classe, na adequa??o ? viola??o do princ?pio, foi renomeado tamb?m a classe TAD, que n?o possuia um nome significativo ao seu contrato. Ap?s aplica??o de Refatora??o temos:

Adequa??o ao princ?pio:

Antes de mostrar a solu??o, a figura abaixo ilustra o contrato de uma Pilha e o contrato de uma Fila. Ambas s?o estruturas de dados com comportamentos diferenciados. A pilha implementa um algoritmo de LIFO (Last In, First Out), o ?ltimo a entrar ? o primeiro a sair. J? a fila implementa um algoritmo de FIFO (First In, First Out), o primeiro a entrar ? o primeiro a sair.

O diagrama de classe original foi refatorado e a classe TAD foi renomeada para Pilha e todos os m?todos referentes ao contrato de uma fila, ap?s aplicado o Extrair Classe e foram movidos para a classe Fila

Implementa??o da classe Pilha

import java.util.Vector;

/**
 *
 * @author Edgard Davidson
 */
public class Pilha 

    private Vector vector;

    public Pilha()
        vector = new Vector();

    public void empilhar(Object element)
        vector.insertElementAt(element, 0);

    public Object desempilhar()
        if (!this.eVazia())
            Object result = vector.firstElement();
            vector.removeElementAt(0);
            return result;
         else
            return null;

    }

    public int obtemTamanho()
        return vector.size();

    public boolean eVazia()
        return vector.isEmpty();

}

Implementa??o da classe Fila

import java.util.Vector;

/**
 *
 * @author Edgard Davidson
 */
public class Fila 

    private Vector vector;

    public Fila()
        vector = new Vector();

    public void enfileirar(Object element)
        vector.add(element);

    public Object desenfileirar()
        if (!this.eVazia())
            Object result = vector.firstElement();
            vector.removeElementAt(0);
            return result;
         else
            return null;

    }

    public int obtemTamanho()
        return vector.size();

    public boolean eVazia()
        return vector.isEmpty();

}

Com essa nova implementa??o, a classe Pilha e a classe Fila s?o extremamente coesas, possuem apenas um prop?sito, uma ?nica responsabilidade e apenas um contrato

Outras refer?ncias

• http://engenhariadesoftwareagil.com/?p=236
  
• http://www.objectmentor.com/resources/articles/srp.pdf
• http://davidhayden.com/blog/dave/archive/2005/05/29/1066.aspx
• http://c2.com/cgi/wiki?SingleResponsibilityPrinciple
• http://msdn.microsoft.com/en-us/magazine/cc546578.aspx
• http://codebetter.com/blogs/david_laribee/archive/2008/09/09/why-solid-gimme-an-s.aspx
• Head First Design patterns. pags 185, 336, 339, 367
• Agile Principles, Patterns, and Practices in C#.
• UML for Java Programmers

Pessoal,

todas as IDEs possuem centenas de teclas de atalho que são muito úteis para aumentar a produtividade do programador. No Flash Builder, não poderia ser diferente, e excluindo a tecla mais importante que é CTRL+S, exibo a seguir 5 teclas essenciais para acelerar o seu desenvolvmento, veja:

CTRL+3 ? Quick Access

Usada para executar um comando da IDE, como por exemplo criar uma classe, abrir as preferências do projeto, ou então executar a aplicação. Acostume-se a usar esta tecla ao invés de ficar procurando itens no menu da aplicação

CTRL+1 Quick Assis

Usada para fornecer sugestões ao código. Uma das aplicações é criar um método/propriedade que não existe, criar event handlers, etc.

CTRL+O Quick Outline

Usada para navegar no arquivo aberto. Por exemplo, se você está em uma classe ou mxml e quer ir para outra parte do código, como um método ou componente qualquer, acione a tecla e faca a busca. É útil também para ver os métodos e propriedades de uma classe.

CTRL+SHIFT+R Open Resource

Permite abrir qualquer classe ou arquivo do projeto, muito útil e mais rápido que ficar procurando a classe no Package Explorer.

ALT+ Seta para cima/baixo

Selecione um código e use estas teclas para ver o resultado. O texto é facilmente movido. Útil para inserir códigos prontos em um laço ou para refatorar a ordem dos métodos.

Aplicando estas teclas de atalho, você irá perceber que a sua programação será mais rápida e produtiva. Experimente!

Se você achar mais alguma tecla interessante, não deixe de comentar !

No Adobe AIR, você pode configurar os perfis de dispositivos, que são um mecanismo para definir as classes que estarão disponivéis para o dispositivo onde seu aplicativo rodara definindo um conjunto de APIs e recursos, normalmente para uma classe particular de dispositivo. Os perfis disponíveis incluem:

• desktop
• extendedDesktop
• mobileDevice
• extendedMobileDevice
• tv
• extendedTV

Você pode obter mais detalhes sobre cada profile e sobre as classes suportadas no seguinte link:
http://help.adobe.com/en_US/air/build/WS144092a96ffef7cc16ddeea2126bb46b82f-8000.html

Faz algum tempo que não escrevo aqui no blog, estou em vários projetos simultâneos e acabei ficando sem gás para escrever no mesmo ritmo que antes. Para compensar, hoje vou disponibilizar um componente de notificação bem bacana que criei para um treinamento in company de Flex. O código aborda diversos conceitos interessantes do Flex 4 como states, FXG e Spark Skinning. Além disso, o componente é um excelente exemplo de onde utilizar o design pattern Singleton.

O componente possui 3 classes:

NotificatorMode.as
Utilizado como um “Enum”, define as constantes que representam os estados do componente: Warning, Success e Failure.

NotificatorManager.as
Implementação do padrão de projeto Singleton, responsável por manipular as mensagens de notificação.

Notificator.mxml
Classe que define a aparência, comportamento e estados do componente de notificação.

A pasta /assets contêm os arquivos que foram gerados no Fireworks e exportados como FXG para o Flash Builder.

Your browser does not support iframes.

Quer o código fonte? Baixe aqui..

Espero que tenham gostado. Até a próxima!

Sockets

Através do namespace System.Net.Sockets, o Windows Phone provê suporte a uma implementação gerenciada de sockets, permitindo que desenvolvedores possam ter um controle rigoroso ao acesso a redes, com esse recurso temos disponível um conjunto de API’s de alto nível, permitindo que o desenvolvedor crie aplicativos que interagem com um cliente utilizando de serviços existentes de TCP.

Existem muitas funcionalidades onde esse recurso pode ser utilizado, como pode exemplo, para criar aplicativos de FTP, e-mail e Chat, com sockets é possível criar aplicativos mais sofisticados e ricos, podendo utilizar de TCP (Transmission Control Protocol) ou UDP (User Datagram Protocol).

Câmera e fotos

Existem duas formas de acessar a câmera no Windows Phone, através das API´s do próprio sistema operacional ou através dos recursos já existentes do Silverlight 4, com as APIs do Windows Phone você tem imagens de alta resolução, além de controle do auto foco, acesso ao modo do flash, entre outros recursos, já com os recursos do Silverlight 4 webcam API, você tem facilidade de gravar vídeos e áudios em arquivos, se você já possui códigos em alguma aplicação Silverlight, você poderá aproveita-los com poucas ou nenhuma modificação quanto ao acesso a webcam.

É possível ter um controle bem flexível da câmera fotográfica do smartphone, através do Windows Phone podemos ter um controle do auto foco da câmera, gerenciar o flash utilizado, acionar a captura da imagem, além de uma série de eventos que podemos utilizar através do Microsoft.Devices.PhotoCamera, no código XAML a representação da câmera pode ser feito através do recurso VideoBrush do Silverlight.

Push Notitications e Live Tiles

Notifications é um poderoso recurso que o Windows Phone implementou de maneira bem interessante, com ele podemos enviar e receber informações para o Windows Phone 7, essas mensagens são enviadas para um serviço da Microsoft, e o serviço online envia para o smartphone, podendo receber a mensagem em seu projeto. Você poderá obter a mensagem recebida e manipular as informações, existem três tipos de Notifications, o tipo RAW, Toast e Tile, resumidamente o primeiro permite receber informações diretamente em sua aplicação, o segundo permite receber um aviso no topo da tela do Windows Phone, a aplicação receberá a notificação mesmo que a sua aplicação não esteja em execução no momento. Já o tipo Tile, é uma notificação nos Tiles que ficam na tela principal do Windows Phone e pode ser acionado quando apertamos o botão Start do aparelho. Na versão Mango, temos mais recursos disponíveis para essas notificações, a notificação do tipo Toast agora pode receber um determinado link que vai para determinado local em sua aplicação e ainda pode passar parâmetros que você pode utilizar para ler e realizar alguma tarefa, dando mais poder para as notificações no Windows Phone, as notificações do tipo Tile também foram incrementadas, agora é possível utilizar um Tile com dois lados e que mude periodicamente ou ainda ter tiles secundários para a mesma aplicação.

Figura 1. Fundo do Tile

Profiler

Performance é um dos assuntos mais importantes quando estamos criando aplicativos em geral, principalmente quando a aplicação vai ser executada em dispositivos com recursos limitados, como é o caso de smartphones, com a versão Mango temos agora uma ferramenta que analisa o perfil da sua aplicação, possibilitando analisar e medir através de gráficos , diversos recursos utilizados.

A ferramenta é totalmente integrada com o Visual Studio, para iniciar o uso do recurso , basta carregar a sua aplicação e no menu Debug, localizar e clicar na opção “Start Windows Phone Performance Analysis”, Figura 2, e clicar em Launch Application, em seguida você executa a rotina que deseja monitorar em seu aplicativo e clica em Stop Profiling, um arquivo com extensão SAP será criado, a cada processo de analise, um arquivo é criado, e você poderá manter um histórico para futuras analises de melhorias. Dentre as informações que a ferramenta apresenta, estão os frame rates, que são os números de renderização da tela do telefone, expressada em frames por segundo (fps), a porcentagem de uso da CPU do telefone, o uso da memória do aplicativo medido em megabytes, a utilização de Storyboards e imagens carregadas, por fim temos um indicativo de quando os eventos do garbage collections foram acionados durante o monitoramento. Se você selecionar um determinado período, o Visual Studio apresentará informações detalhadas sobre diversos pontos do aplicativo.

Figura 2. Performance Analysis

Figura 3. Analise detalhada da aplicação

Emulador

O emulador também sofreu algumas melhorias, duas delas são muito interessantes , como a possibilidade de testar no emulador os sensores de acelerômetro, Figura 4, e localização. Agora podemos simular através do emulador a leitura desses sensores, não precisando ter um equipamento físico para poder criar uma aplicação, basta você utilizar o mouse que o emulador vai responder conforme a ação esperada pelo aparelho real. No caso da utilização de recursos de localização, você ainda conta com uma barra de ferramentas com controles de busca, inclusão de indicativos de localização e gravação da localização, o emulador ainda contém alguns outros recursos que talvez sejam disponibilizados na versão final, como a possibilidade de adicionar gravações referente as simulações.

Figura 4. Emulador

Device Status

O namespace Microsoft.Phone.Info fornece informações sobre o equipamento, na versão anterior, era utilizado a classe DeviceExtendedProperties para obter alguns dados sobre o equipamento, na versão Mango essa tarefa passa a ser realizada por DeviceStatus, você pode obter informações como o total de memória, a versão do hardware e o nome do fabricante do equipamento. Através do PowerSource, podemos verificar se o dispositivo está funcionando com bateria ou conectado a uma fonte de alimentação externa. Outro recurso disponível é a possibilidade de verificar se existe ou não um teclado físico no smartphone através da propriedade IsKeyboardPresent.

Local Database

Existem dois tipos de persistências no Windows Phone 7, o Transient Data e o Persistent Data, você pode manipular informações através de Isolated Storage, um recurso que permite registrar e recuperar informações no próprio aparelho, essa forma de persistência de dados é chamada de “Persistent Data”, ou armazenar informações na memória, Transient Data, sua aplicação pode manipular esses dados conforme o seu ciclo de vida, porém na versão mango uma nova forma de Persistent Data foi adicionada, o local Database.

Agora temos a possibilidade de utilizar uma base de dados local em uma aplicação, antes da disponibilização das ferramentas betas da versão mango para desenvolvedores e da documentação oficial, falava-se que uma versão do SQL CE estaria disponível para ser utilizada, porém em sua documentação oficial a base de dados é citada somente como local database, uma versão própria do Windows Phone, um grande diferencial de produtividade está no suporte ao LINQ to SQL para operações em base de dados.

O local database permite armazenar dados relacionais dentro de um ambiente residente no Isolated Storage, por estar dentro do Isolated Storage, ele somente pode ser acessado pela aplicação correspondente, e roda somente no processo do aplicativo, não sendo executada com um serviço continuo, a manipulação de dados locais são acessados apenas através de LINQ to SQL, não tendo suporte ao Transact-SQL.

Launchers and Choosers

Os Launchers e Choosers são APIs que acessam alguns recursos do sistema operacional, eles disponibilizam recursos complexos deixando transparentes para que o desenvolvedor através de API´s, os Launchers são tarefas que somente são iniciadas pela sua aplicação, teoricamente, você não tem nenhum tipo de retorno da API, somente você pode inicia-los , passando os parâmetros que ela vai utilizar para realizar a tarefa. Já os Chooser também iniciam uma tarefa, mas a principal diferença é que os Choosers retornam algum dado que você poderá trabalhar em sua aplicação, um exemplo seria o EmailAddressChooserTask, com ele podemos apresentar ao usuário a lista de e-mails cadastrados no aparelho, quando um e-mail é selecionado, podemos obter essa informação e utilizar para enviar um e-mail através de um Launcher chamado EmailComposeTask, que não retorna nenhuma informação,dessa forma algumas tarefas que poderiam ser bem complexas são facilitas com os Launchers e Choosers. Na versão Mango temos novos Launchers and Choosers adicionados as API´s são eles:

Address Chooser Task : Inicia a lista de contatos da aplicação e permite a seleção.

Game Invite Task : API utilizada em jogos aprovados no Xbox Live que permite convidar jogadores para uma partida multi-player em um Game.

Save Ringtone Task : Permite gravar um arquivo MP3 ou WMA na lista de ringtones do sistema operacional.

Bing Maps Task : Inicia o Bing Maps, permitindo setar a propriedade center com uma posição geográfica.

Bing Maps Directions Task : Inicia o Bing Maps permitindo informar e receber informações sobre dois pontos.

Conclusão

O Windows Phone 7 chegou trazendo uma nova plataforma de desenvolvimento para dispositivos móveis, a Microsoft utilizou o que existe de mais moderno para criar o seu sistema operacional, dando suporte as melhores práticas de desenvolvimento e integração com aplicativos, a versão Mango contém mais de 500 novos recursos e confirma o investimento da Microsoft em sua plataforma mobile.