A Cognitiva Soluções Empresariais disponibiliza o serviço de Fábrica de Software.
Focada em tecnologias inovadoras. Buscando sempre a superação em virtude de desenvolver sistemas sob demanda com alto valor agregado.

Utilizando das boas práticas de programação, engenharia de software e de metologias ágeis. Temos como objetivo a entrega de produtos que além de atender as necessidades dos nossos clientes, sejam reconhecidas pela qualidade e excelência.

Deseja obter mais informações sobre este serviço? Entre em contato aqui.

É grande a expectativa pelos desenvolvedores .net para a chegada e comercialização do Windows Phone no Brasil, a plataforma chega bem completa e robusta, atendendo diversas necessidades dos usuários e desenvolvedore e permitindo a criação de aplicativos utilizando as mais modernas tecnologias Microsoft.
Apresentada no evento MIX 11 da Microsoft, a versão com o codinome Mango, chegou com mais de 500 novidades, são tantos recursos que não é possível cobri-los em um único artigo, podemos destacar algumas melhorias como sendo essenciais para o crescimento da plataforma, como o suporte a multitarefa, a atualização da versão do Silverlight para o Silverlight 4 e a atualização do Browser para a versão do Internet Explorer 9 com suporte ao HTML5, essas são sem dúvidas grandes mudanças tanto para o desenvolvedor como para o usuário.

Para os desenvolvedores foram diversas melhorias e para os usuários não foi diferente, houve uma melhor integração com o Skydrive, possibilitando compartilhar fotos por e-mail e SMS, podemos também compartilhar vídeos realizando o upload em background, navegar pelas pastas no Skydrive, realizar pesquisas de conteúdo, entre diversos outros recursos de integração com esse excelente serviço da Microsoft.

Outro recurso interessante é o Bing Vision, que é uma ferramenta que usa a câmera do telefone para reconhecer imagens, por exemplo, ao focar a capa de um determinado livro ele apresenta uma lista de resultados onde o livro é citado, já o Bing Áudio, é um mecanismo inteligente de busca de áudio, ele pode até reconhecer uma música que está sendo tocada e apresentar resultados sobre a música, esses são somente alguns exemplos, mas houve melhorias e atualizações em diversos HUBs, sensores e recursos do sistema operacional, além de uma forte integração com redes sociais como facebook, twitter e linkedIn.

As ferramentas de desenvolvimento para a versão Mango já estão disponíveis para download em versão Beta, muitas informações e recursos podem ficar diferentes na versão final, mas geralmente são mudanças pequenas. Com as ferramentas já é possível criar e testar todo o aplicativo com o Visual Studio 2010 e utilizar todo o poder do emulador que está integrado totalmente com o Expression Blend for Windows Phone ou com o Visual Studio 2010.

Download: Windows Phone Developer Tools 7.1 Beta tools

Os programadores Visual Basic .net agora podem criar aplicativos para o Windows Phone tanto em Silverlight como no XNA Framework, o Visual Basic é totalmente integrado com o Windows Phone Developers Tools 7.1 Beta, não sendo necessário instalar nenhuma ferramenta a parte. No Mango houve melhorias internas no sistema operacional que resultou em uma melhor performance na execução dos aplicativos em geral, alguns recursos agora rodam em threads background, deixando a interface do usuário com uma resposta mais rápida, essas melhorias são refletidas em sua aplicação e você não precisa codificar nada para usar desses benefícios, além dessas melhorias internas ouve também a inclusão de recursos essenciais para a criação de aplicações, como o suporte a OData e a inclusão de um banco de dados local.

O Windows Phone Marketplace também está em constante crescimento, com poucos meses de lançamento, a loja de aplicativos do Windows Phone 7 é constantemente atualizada com dezenas de novos aplicativos, o número de desenvolvedores e aplicativos podem aumentar significativamente com está atualização com codinome Mango, é previsto que o Marketplace esteja disponível para que os usuários possam comprar aplicativos em um total de 35 países, inclusive o Brasil e com suporte a 16 novas línguas, contando com o Português do Brasil.

Se você é um desenvolvedor da plataforma Microsoft .net e ainda não começou a desenvolver para o Windows Phone, é importante saber que a curva de aprendizado não é muito grande, principalmente se você já tem conhecimento na plataforma Silverlight ou XNA, o Windows Phone pode se tornar competitivo nos próximos anos, principalmente com a entrada e comercialização de equipamentos pelas operadoras no Brasil, somado com a recente parceria com a Nokia, umas das mais importantes empresas do setor, e a compra do Skype pela Microsoft, que vai trazer esse aguardado software para a plataforma .net, além de novas parcerias com fabricantes, tudo isso está fortalecendo a tecnologia mais recente da plataforma mobile da Microsoft.

Modelo de execução – Estado dormant

Houve uma pequena modificação no modelo de execução de aplicativos no Windows Phone Mango, nesta versão temos um novo estado da aplicação chamado dormant, para entendê-lo, vamos relembrar como funciona o ciclo de vida de uma aplicação no Windows Phone, temos quatro eventos que são acionados como apoio durante o uso do aplicativo, são eles, launching, closing, activated e deactivated, e junto com esses eventos podemos ter dois estado da aplicação, running e tombstoned, e para auxiliar com a manipulação de estados podemos utilizar os métodos OnNavigatedTo e OnNavigatedFrom. Quando você inicia uma aplicação, por exemplo, através do botão Start clicando em algum Tile, automaticamente uma nova instância do aplicativo será criada na memória, neste momento o evento Launching é acionado, ou seja, sempre que uma nova instância é criado, o evento Launching será chamado, neste evento temos que evitar a utilização de códigos que possam ser demorados e atrapalhar a experiência de uso do usuário da aplicação, além de que o Windows Phone Marketplace também informa limites de tempo para que a sua aplicação inicie. Após o evento Launching ser acionado, a sua aplicação entra em um estado chamado Running, neste momento sua aplicação está em execução e você poderá realizar tarefas e o usuário poderá navegar em sua aplicação. Neste momento se o usuário apertar o botão Start, por exemplo, ele estará acionando um evento chamado Deactivated e sua aplicação deverá salvar qualquer estado do aplicativo que você deseja restaurar caso o usuário retorne para sua aplicação através do botão Back, é neste ponto que houve um mudança com a versão Mango, agora existem dois
estados utilizados neste processo, o dormant e o tombstoned, sua aplicação entre em estado dormant antes de entrar em tombstoned, o que não acontecia na versão anterior, onde o aplicativo entrava direto em tombstoned. Quando o usuário navega para fora da sua aplicação , o Windows Phone coloca o aplicativo no estado dormant, neste momento todo o processamento, ou seja, todas as threads, são paradas, mas a aplicação ainda está na memória do aplicativo, este estado permite retornar a aplicação utilizando o máximo de performance, pois não é necessário recriar qualquer estado pois todos foram preservados. Se um aplicativo está no estado dormant e o usuário iniciar outro aplicativo, o sistema operacional vai verificar se esse novo aplicativo iniciado precisa utilizar mais memória do que o device disponibiliza como livre no momento,se isso ocorrer, a sua aplicação poderá ser escolhida para sair do estado dormant e entrar no estado tombstoned.

Mais informações : http://msdn.microsoft.com/en-us/library/ff817008(v=vs.92).aspx

Background Agents

Com os Background Agents podemos realizar algumas tarefas mesmo que a aplicação não esteja em execução, existem duas formas de realizar esse agendamento de tarefas, através de scheduled notifications ou scheduled tasks.

Uma scheduled notification é um aviso, que pode ser do tipo Alarm ou Reminder, o tipo Alarm permite que você especifique um arquivo de som para tocar quando a notificação é acionada, o tipo Reminder, você pode especificar uma URI para sua aplicação, quando o usuário clicar na notificação, a aplicação será executada e a URI será passado com parâmetro.

Já um Scheduled Task permite que você execute uma tarefa em background, mesmo quando a aplicação não está sendo executada, cada aplicação pode ter um único agente, que será registrando em sua aplicação e você pode especificar o tipo de scheduled que será executado, existem dois tipos, o PeriodicTask e o ResourceIntensiveTask, o primeiro é indicado para tarefas onde o tempo de execução será curto, como por exemplo, armazenar uma pequena quantidade de dados, e pode ser utilizado regularmente, já o ResourceIntensiveTask, tem sua utilização mais rara, pode ser utilizado para tarefas mais demoradas e que utilizam mais dos recursos do smartphone, com por exemplo a sincronização de um grande volume de dados.

File Transfers

Na versão mango temos disponíveis algumas APIs para a manipulação de uploads e downloads de arquivos no Windows Phone, esses arquivos podem ser enfileirados e executados em segundo plano (background), o Windows Phone fornece meios de verificar o status da transferência dos arquivos e ainda fornece meios de monitorar o progresso do download ou upload.

Áudio Background

Tocar um arquivo de som rodando em background, mesmo que a aplicação não esteja em foreground, se tornou uma tarefa fácil e gerenciada pelo sistema operacional, o suporte ao áudio em background é fornecido pelo namespace Microsoft.Phone.BackgroundAudio, com ele é possível acionar uma música e mesmo que o usuário inicie outros aplicativos, a música continuará em execução e o usuário ainda terá o acesso aos controles de aumentar e diminuir o volume.

Mais informações: http://msdn.microsoft.com/en-us/library/hh202978(v=vs.92).aspx

Sensores

Os smartphones estão ficando cada vez mais sofisticados e uma série de sensores estão sendo disponibilizados com esses modernos aparelhos, na versão mango temos disponível além do conhecido acelerômetro, mais dois sensores igualmente importantes, como a bússola e o giroscópio.

A bússola permite obter o ângulo pelo qual o smartphone é girado em relação ao polo magnético da terra, sua aplicação pode realizar a leitura dessas forças magnéticas e utilizar para realizar alguma ação, o sensor bussola não é um item considerado obrigatório para os fabricantes de equipamentos utilizarem com o Windows Phone, portanto se a sua aplicação for utilizar o recurso , ele precisa informa-lo e ainda verificar se o recurso está presente através de recursos do sistema operacional. Eventualmente a bussola pode ficar descalibrada, os smartphones com o sensor possuem recursos para a calibração da bussola, onde um movimento em formado de infinito é realizado.

O Giroscópio é outro sensor disponível para o desenvolvedor utilizar em suas aplicações, com ele podemos medir a velocidade de rotação do smartphone dos eixos X, Y e X. Todos os equipamentos com Windows Phone possuem o acelerômetro como sensor obrigatório, o acelerômetro consegue medir a aceleração do smartphone em movimentos mais intensos, no caso de uma simples e leve rotação de eixos, esses valores não podem ser lidos através do acelerômetro, já com o giroscópio é possível obter os valores quanto a velocidade de rotação do celular.

Juntos, o giroscópio, acelerômetro e a bussola, forma um conjunto completo que pode ser utilizado para formar um sofisticado sensor de movimentos, para simplificar essa integração, a versão Mango disponibiliza através do Microsoft.Devices.Sensors.Motion, um conjunto de recursos que facilitam a leitura dos resultados gerados pelos sensores para que você possa utilizar em sua aplicação.

continua…

Eu confesso que nunca me interessei em desenvolver sites e muito menos aplicações web utilizando ASP.net, sempre achei que a metodologia “drag and drop” que o Web Forms nos proporciona não funciona legal na web, pois ela gera muito “lixo” para o navegador, e isso é crucial em uma WebAPP.

Portanto, desde que migrei de desktop (Delphi 7) para web, tenho trabalhado com o nosso querido Flex no Front End e o C#.net no Back End. Mas desde que o ASP.net MVC foi lançado, tenho acompanhado de perto a sua evolução, e confesso que ele tem me agradado bastante.

Para não perder o costume, venho hoje compartilhar com vocês um pouco do que tenho estudado, este post faz uma comparação de um projeto idêntico criado usando as duas metodologias.

Então chega de conversa e vamos ao que interessa:

As ferramentas que utilizei para criar os projetos foram:
• SQL Server 2008 Express
• Visual Web Developer Express 2010
• Framework ASP.net MVC 2.0

O projeto acessa uma base de dados com apenas uma tabela, com a seguinte estrutura:

Não utilizei nenhum framework ORM, fiz o mapeamento das entidades manualmente, usando as classes nativas do Framework. (SqlConnection, SqlCommand e SqlDataReader).

Quando criei os projetos, utilizei os templates do prório Visual Web Developer:

Para o projeto Web Forms, usei ASP.NET Web Application.
Para o projeto MVC usei: ASP.NET MVC 2 Web Application.

É claro que não vou fazer um passo a passo de como criar o projeto, o foco deste post não é isso, mas depois de pronto, nosso Solution Explorer do projeto WebForms ficará assim:

Já o projeto MVC, tem uma estrutura um pouco maior, porque ele trabalha completamente “tipado”, temos as classes Model, Controller e View, como manda o figurino:

Certo, agora vamos ao objetivo, quando executo o projeto WebForms e acesso a página de clientes, o Framework gera este código HTML:

"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">"http://www.w3.org/1999/xhtml" xml:lang="en">
"../Styles/Site.css" rel="stylesheet" type="text/css" />
"post" action="default.aspx" id="ctl01">
class="aspNetHidden">
"hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
"hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
"hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="ZhpEPEbRGaEf3wxNFvEkKLAz6ze4Y1776/kxLQ+oQoJx5Ew6ZrkBOLulNNEfu2T+c9uFRH7RTl5UUrZ3A1gK1BMKQc174Sha+0Wt5wmfhTKcGIb1YUgfoyjwcO8TYaR3U3o3l/07IemJNiwmeH8cM7BzSKkWiBTRuwjyI6u7VHlH7TyWLCMw0bneQ8edbb2YBMnGslvv7YSjWb5RdYMIjhu77ZE4CwQwK75UxHI1QZUgHjIaNP7MrZpoxi+tQbCBVW9Lc3jZCq0gbouSkWw7epm9WZknpiH5T68BTGirDfP4BfUZygsyB6aHmrpdN47pKJz7kFH78soAuE4Yd1NWNk9mHK+6ErcoVe3EkH8ycfXm51UwzkwNp2XRdr2s2AANsWpDdxNhyDTo2Mia2/YrPGirUzqV62RWlVWpS/KBwBpdtSLlYVnLaU6eJyjrJhqXxKzTa8b3F1av8h40cX5teT+0odXAWB3E2GcrE9XGfwa1ACk5QQlFsh+UplF/dEuzes6UBjJd9LQS7kPVabfzs/y8L3BRsK0Rtb0i1unXfHMuq3eVg/XQGnwb9uEhL5EdHjniskkoUzQh1T2yJfPwajrjxU06M5Ba43Soj8pk03isqi4tBqBllPVkv13Hyz8eapd85VejaO+3CUqXVr3J9/3MvZWjNcA2QOef7H4xKmtVExbxingFQqj5K5appmJReVczk8/HLCOnLD+Wa5/7CKWTj/OucQgIgPYnGEpzMZUlKJZFLAeFfwwkR2XVZcyyCoYWjK2pJX5zuCXMVkMxKCCuWjVvtl3GPfUkz1nsgP/Jtyq7vSdiXdGE/qxV8yRGJN5h4MlvVOfYq2gKspcNIZzwCzVCidhdoY8SYjnz+qyIXmXxXD3VkF2XGbcId86i/qOkwOyk9UcAS8iR+Es/MkQg7WximaQQji+o67grOaE=" />






class="aspNetHidden">
"hidden" name="__VIEWSTATEENCRYPTED" id="__VIEWSTATEENCRYPTED" value="" />
"hidden" name="__PREVIOUSPAGE" id="__PREVIOUSPAGE" value="J0z-AYjFMhWT0kpqMD21gr0HoEKRmyw5_w3a37YYi27BAPn9DepNebG_20nPZ-VajOl1_KCPnab6uApAzjeQe7rOkN95u7baMYMKLA59Jpw1" />
"hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="IRcnHy6RQ1JCPCa5l/6k5JvtDNRbcbaJH7wDUCh/MVtgwLHo5W/iwGkTGRYeZHjYgqrWjjGjzZQvt+FJuMho2GE+Qf3syKzyeGXquF9a/Ws577KUO6oFdTWrhmsBXMMh" />

class="page">
class="header">
class="title">
                    My ASP.NET Application                

class="loginDisplay">

                        [ "../Account/Login.aspx" id="HeadLoginView_HeadLoginStatus">Log In ]
class="clear hideSkiplink">                "#NavigationMenu_SkipLink">"Skip Navigation Links" src="/WebResource.axd?d=xFBnuqKYnqgWTzzLZBOde45ezhDnXgdvOgtOQCvZwJw6xfKBic_vxFOBRotUqhEobwKQWWgbNXfNYvZsldu9uZj6j6aYf49eocT9vsEpgtM1&t=634356288728593750" width="0" height="0" style="border-width:0px;" />
class="menu" id="NavigationMenu">
class="level1">
class="level1" href="../Default.aspx">Home
class="level1" href="../About.aspx">About



"NavigationMenu_SkipLink">            

class="main">

        Listagem Completa de Clientes    

    

    

"0" rules="all" border="1" id="MainContent_GridView1" style="border-collapse:collapse;">

"col">Id_Cliente
"col">Nome
"col">CPF
"col">RG
"col">Idade
"col"> 
"col"> 


17
Jo?o
123.123.123-12
12.312.123-1
30
"Edita.aspx?Id_Cliente=17">Editar


                    "return confirm('Tem certeza?');" id="MainContent_GridView1_LinkButton1_0" href="javascript:__doPostBack('ctl00$MainContent$GridView1$ctl02$LinkButton1','')">Excluir                


19
Jos?
444.444.444-44
44.444.444-4
21
"Edita.aspx?Id_Cliente=19">Editar
                    "return confirm('Tem certeza?');" id="MainContent_GridView1_LinkButton1_1" href="javascript:__doPostBack('ctl00$MainContent$GridView1$ctl03$LinkButton1','')">Excluir



18
Maria
999.999.999-99
99.999.999-9
35
"Edita.aspx?Id_Cliente=18">Editar
                    "return confirm('Tem certeza?');" id="MainContent_GridView1_LinkButton1_2" href="javascript:__doPostBack('ctl00$MainContent$GridView1$ctl04$LinkButton1','')">Excluir                





"submit" name="ctl00$MainContent$btnInserir" value="Inserir novo cliente" onclick="javascript:WebForm_DoPostBackWithOptions(new WebForm_PostBackOptions("ctl00$MainContent$btnInserir", "", false, "", "Insere.aspx", false, false))" id="MainContent_btnInserir" />    

class="clear">

class="footer">

Dêem uma olhada em quanto código os componentes criam. É muita coisa, imaginem isso em um grande portal? Americanas.com gerando este código? Meio inviável não? Aproveito para destacar o código gerado pelo ViewState, herói e vilão do Web Forms.

Agora vamos comparar a mesma página gerada pelo projeto MVC:

"-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">"http://www.w3.org/1999/xhtml">
"Content/Site.css" rel="stylesheet" type="text/css" />


class="page">
"header">
"title">
My MVC Application

"logindisplay">

        [ "/Account/LogOn">Log On ]
"menucontainer">
"menu">
"/">Home
"/Home/About">About


"main">
Listagem completa de clientes:


                Código            
                Nome            
                CPF            


                RG            
                Idade            





                30            
                Jo?o            
                123.123.123-12            
                12.312.123-1            
                30            
                "/Cliente/Edit?Id_Cliente=30">Editar |                "/Cliente/Delete?Id_Cliente=30" onclick="return confirm('Tem certeza?');">Excluir |            


                32            
                Jos?            
                444.444.444-44            
                44.444.444-4            
                21            
                "/Cliente/Edit?Id_Cliente=32">Editar |                "/Cliente/Delete?Id_Cliente=32" onclick="return confirm('Tem certeza?');">Excluir |            


                31            
                Maria            
                999.999.999-99            
                99.999.999-9            
                35            
                "/Cliente/Edit?Id_Cliente=31">Editar |                "/Cliente/Delete?Id_Cliente=31" onclick="return confirm('Tem certeza?');">Excluir |            



        "/Cliente/Create">Novo cliente...    
"footer">

O que acham? As duas páginas fazem exatamente a mesma coisa, no entato o MVC gera beeeem menos código.

Bom pessoal, essa é apenas uma das vantagens do MVC, posso destacar outras:

• Controle total do código que será enviado ao navegador;
• Arquitetura em camadas, códigos completamente separados;
• Classes que auxiliam a geração do HTML para o browser de acordo com as ações do Controlador, sem lixo!;
• Facilidade de se implementar Ajax (de verdade) no seu projeto.
• Integração com o Jquery usando classes do Framework;

Bom é isso, vou me despedindo, mas antes deixo o código fonte dos dois projetos disponíveis para download.

A renderização da interface gráfica do Windows Phone 7 foi projetada para buscar o máximo de performance que o smartphone pode proporcionar, a UI Thread é responsável pelo desenho da interface principal do aplicativo, quando criamos um software para o WP7, devemos evitar bloquear a UI Thread, pois ela está diretamente relacionada a performance do software e também com a experiência do usuário com o aplicativo.

Os smartphones com Windows Phone 7, tem disponível um recurso que utiliza a aceleração da GPU, aumentando consideravelmente o desempenho gráfico para algumas tarefas relacionadas a manipulação de imagens e animações, principalmente as que usam a rotação de eixos, escalas e alguns tipos de? animações que usam de Storyboard. Não é necessário acionar nada para que alguns tipos de Storyboards utilizem esse recurso, eles automaticamente usam o Composition Thread ou também chamado de Render Thread.

O Render Thread pode ser usado para animações simples utilizando DoubleAnimation ou Easing Functions, ou em propriedades? como Opacity, Render Transforms e Rectangular Clip. Habilitando o EnableRedrawRegions podemos ver quais regiões na aplicação estão sendo desenhadas no momento, visualizando? quadro a quadro:

Application.Current.Host.Settings.EnableRedrawRegions = true;

Composition Frame Rate Thread? e UI Frame Rate Thread

Quando executamos um aplicativo através do Visual Studio 2010 com o smartphone plugado no computador,? podemos visualizar alguns números no lado superior direito da tela, esses números servem para você ter como parâmetro alguns pontos sobre a renderização gráfica, memória, etc, os dois primeiros números de 3 dígitos são referente a Render Thread e a UI Thread.

O Composition Frame Rate Thread está associado a velocidade com que a tela é atualizada em uma thread separada da UI Thread, como referência, o Windows Phone 7 utiliza o valor 30 como ponto de equilíbrio, ou seja, quando for abaixo de 30, os números estarão na cor vermelha, acima de 30 ele ficará com a cor default, o valor mais próximo de uma boa performance é 60, sua aplicação deve buscar sempre se aproximar desse número.

O UI Frame Rate Thread mostra a taxa de atualização da Thread principal, enquanto a interface do usuário estiver ativa, o valor de 30 também foi definido como ponto de equilíbrio, ficando vermelho se a aplicação estiver abaixo deste valor, porém este valor deve ser acima de 20 para ter um tempo de resposta aceitável e quanto maior o valor , o tempo de resposta será mais rápido.

Exemplo prático de UI Thread VS Render Thread

Vou criar um aplicativo simples com dois elementos Ellipse na tela, um com o nome BolaVermelha e outro com BolaAzul, as duas Ellipses serão animadas na tela, a BolaAzul vai utilizar o Render Thread, pois vamos utilizar uma Storyboard com a propriedade RenderTransform, já a BolaVermelha vamos anima-lá atualizando a mesma propriedade, mas utilizando um timer DispatcherTimer para atualizar a propriedade, ou seja, não utilizaremos uma Storyboard para realizar a animação e ela estará utilizando a UI Thread.

   1:    public partial class MainPage : PhoneApplicationPage

   2:      

   3:  

   4:          DispatcherTimer timer;

   5:          RotateTransform rotateVermelho;

   6:          bool bateVolta;

   7:          int contador = 0;

   8:  ? 

   9:          public MainPage()

  10:          

  11:              InitializeComponent();

  12:              Loaded += new RoutedEventHandler(MainPage_Loaded);

  13:  ? 

  14:              Application.Current.Host.Settings.EnableRedrawRegions = true;

  15:  

  16:              this.BolaVermelha.RenderTransform =

  17:                  new RotateTransform();

  18:              this.BolaAzul.RenderTransform =

  19:               new RotateTransform();

  20:  

  21:              rotateVermelho =

  22:              BolaVermelha.RenderTransform as RotateTransform;

  23:              rotateVermelho.Angle = -50;

  24:  ? 

  25:              timer = new DispatcherTimer();

  26:              timer.Tick += new EventHandler(timer_Tick);

  27:              timer.Interval = new TimeSpan(0, 0, 0, 0, 33);

  28:              timer.Start();

  29:  ? 

  30:              bateVolta = false;

  31:  

  32:          

  33:  ? 

  34:          void MainPage_Loaded(object sender, RoutedEventArgs e)

  35:          

  36:  ? 

  37:              Storyboard storyboard = new Storyboard();

  38:              DoubleAnimation animation = new DoubleAnimation();

  39:              animation.From = 0;

  40:              animation.To = 180;

  41:              animation.Duration = new Duration(new TimeSpan(0, 0, 1));

  42:              animation.AutoReverse = true;

  43:              Storyboard.SetTarget(animation, this.BolaAzul.RenderTransform);

  44:              Storyboard.SetTargetProperty(animation, new PropertyPath("Angle"));

  45:              storyboard.Children.Add(animation);

  46:              storyboard.RepeatBehavior = RepeatBehavior.Forever;

  47:              storyboard.Begin();

  48:  

  49:          

  50:  ? 

  51:          void timer_Tick(object sender, EventArgs e)

  52:          

  53:              if (rotateVermelho .Angle == 120)

  54:              

  55:                  bateVolta = true;

  56:              

  57:              if (rotateVermelho.Angle == -50)

  58:              

  59:                  bateVolta = false;

  60:              

  61:  ? 

  62:              if (bateVolta == true)

  63:              

  64:                  rotateVermelho.Angle -= 1;

  65:              

  66:              else

  67:              

  68:                  rotateVermelho.Angle += 1;

  69:              

  70:  ? 

  71:              contador++;

  72:  ? 

  73:              if (contador == 600)

  74:              

  75:                  MessageBox.Show("Parando a UI Thread");

  76:                  Thread.Sleep(1000);

  77:              

  78:  ? 

  79:              if (contador == 1000)

  80:              

  81:                  MessageBox.Show("Inserindo BitmapCache");

  82:                  BitmapCache cache = new BitmapCache();

  83:                  BolaVermelha.CacheMode = cache;

  84:  ? 

  85:              

  86:  ? 

  87:          }

  88:  ? 

  89:      }

?

Na linha 71 criei um contador, quando chegar a 600, ele vai bloquear a UI Thread, na linha 76, a UI Thread é bloqueada propositalmente utilizando Thread.Sleep, neste momento você irá notar que a animação da? BolaVermelha irá parar com base no tempo definido em Sleep, pois a sua Thread está bloqueada, mas a BolaAzul continuará a se movimentar.

Quando o contador chegar a 1000,? vou adicionar um BitmapCache na propriedade CacheMode da BolaVermelha, em alguns casos onde não estamos utilizando a Render Thread, podemos criar um cache, ou seja, colocar os bitmaps na memória, e com isso aproveitar da aceleração da GPU, com performance semelhante a Composition Thread, porém a BolaVermelha continuará na UI Thread,? uma simples mensagem na tela utilizando um MessageBox irá bloquear a UI Thread enquanto a BolaAzul continuará em movimento.

Conclusão

UI Thread e Composition Thread são recursos fundamentais que o Windows Phone 7 utiliza para apresentar a interface gráfica, conhecendo essas Threads você poderá melhorar a perfomance da sua aplicação, os smartphones são equipamentos limitados se comparado a um PC, conhecer quando utilizar determinado recurso pode fazer muita diferença, existem diversos outros pontos a serem considerados quanto ao monitoramento da aplicação com objetivo de melhorar a perfomance, neste artigo somente apresentei uma introdução sobre o assunto.

Alguns recursos podem não funcionar como esperado no emulador, pois depende de diversos fatores como o suporte a DirectX pela placa de video, neste link você encontra mais informações:

WP7/Silverlight Graphics Performance

Mais informações sobre Bitmap Cache : Bitmap Cache

Mais informações sobre performance: Performance Considerations in Applications for Windows Phone

Esta é uma tradução do seguinte artigo: 10 Things A Good Flex Developer Should Know

Para ser um bom programador Flex é preciso mais que simplesmente saber como usar alguns componentes nativos do Flex. É preciso muito mais.

Aqui está minha contribuição sobre o assunto… juntamente com alguns recursos ou algumas palavras-chave que você poderá pesquisar facilmente através do Google.

Por favor, comente no blog se você achar que esqueci algo (o que é inevitável) ou se quiser sugerir alguns recursos interessantes que devo acrescentar.

1- Programação orientada a Objetos (OO)

O Flex se baseia na linguagem ActionScript3, que é totalmente orientada a objetos. Embora não seja um conceito fácil de aprender, programação orientada a objeto é um pré-requisito para aprender Flex. Se já possui experiência com OO (Java, C#, Ruby, etc), então você está pronto. Se não, você precisará pegar um livro sobre OO e começar a aprender o mais rápido possível.

· Head First Java (Java? Sim, Eu sei. Mas confie em mim.)

· Object-oriented programming with ActionScript 3.0

Nota: Alguns de vocês poderão perguntar – “O que são padrões de projetos?”. Vamos dar um passo de cada vez? Preocupe-se em entender classes e objetos, interfaces, herança, composição, polimorfismo, encapsulamento, etc. Só então considere estudar padrões de projetos. De fato, se eu escrever um post intitulado “10 coisas que um GRANDE programador Flex deve saber”, padrões de projeto estará nessa lista.

2- ActionScript/MXML

ActionScript é a linguagem de programação usada juntamente com MXML para criar aplicações Flex. MXML é uma linguagem de marcação baseada em XML. Cada tag MXML é mapeada diretamente para uma classe ActionScript correspondente. MXML é usado pelos desenvolvedores Flex principalmente para apresentar a interface do usuário, enquanto que, o ActionScript é usado para a lógica de negócio. Com exceções, é claro.

O Framework Flex inclui centenas de classes ActionScript e interfaces usadas para desenvolver aplicações Flex. Seu nível de habilidade como um desenvolvedor Flex está diretamente ligado ao seu conhecimento em relação ao ActionScript e MXML.

· Flex in a Week

· Tour De Flex

· Essential ActionScript 3.0

Nota: Fique ? vontade com a API do Flex. Como um desenvolvedor Flex, você vai usá-la diariamente.

3- Debugging

Boa parte do tempo de qualquer programador é gasto no debugging. Obviamente, é necessário debugar para rastrear a causa de bugs. No entanto, também é uma ótima maneira de conhecer o código fonte.

Felizmente, existem muitas ferramentas disponíveis para ajudá-lo com o trabalho de debugging. Invista algum tempo para aprender essas ferramentas. Seu investimento irá proporcionar retorno imediato.

· Flash Builder 4.5 Debugger

· De MonsterDebugger

· Kap Inspect

4- Programação orientada a eventos

Aplicações Flex são orientadas a eventos. Toda ação é o resultado de um evento assíncrono.

Como um desenvolvedor Flex, você deve saber como responder a eventos e como criar e disparar eventos. Para isso, é necessária uma sólida compreensão da arquitetura de eventos do Flex, incluindo familiaridade com os seguintes conceitos:

· Eventos nativos (Flash Player ou Framework de eventos Flex)

· Eventos customizados (Eventos criados pelo desenvolvedor, que estende a classe Event ou uma de suas subclasses)

· Disparar eventos, propagação de eventos (ver classe EventDispatcher e seu método dispatchEvent)

· Event listeners, event handlers (ver classe EventDispatcher e seus métodos addEventListener e removeEventListener)

· Fases do evento (capture, target & bubbling phases; target vs. currentTarget)

· Objetos do evento, tipos de eventos (ver classe Event e subclasses)

· Comportamento do evento default (ver classe Event e subclasses e seu método preventDefault)

5- Data binding

Aparentemente, data binding é um “no brainer”[1]. É só vincular o valor de uma propriedade ao valor de outra propriedade usando chaves. Quando o valor da propriedade de origem for alterado, o valor da propriedade de destino também é alterado.

No entanto, existe uma sobrecarga associada ao uso indiscriminado de data binding, podendo haver implicações no desempenho. Uma sólida compreensão de data binding ajudará a determinar quando é apropriado o seu uso e quando não é.

· Flex Tips – Using Bindable Metadata Events

· Michael Labriola’s presentation entitled Diving in the Data Binding Waters

6- Item renderers

Uma característica de uma aplicação Flex bem projetada é a apresentação dos dados de uma forma visualmente atraente. O Flex oferece uma série de controles baseados em listas (DataGrid, List, TileList, HorizontalList, etc) responsável pela apresentação dos dados. Portanto, pode-se personalizar a exibição dos dados com a ajuda de item renderers.

Você irá consumir muito tempo trabalhando com item renderers. Então é melhor saber bem como ele funciona.

· Flex Examples – Item Renderers in Practice

· A Deep Dive into Flex 4 Lists and Layouts

7- Acesso remoto a dados

Você conhece muitas aplicações que não interagem com os dados? Eu também não. Saiba como recuperar dados através de HTTPServive, WebService e RemoteObject. A arquitetura do framework Flex também poderá ajudá-lo com isso (ver #9).

· Retrieving and handling data with HTTPService

· Retrieving and handling data with WebService

· Retrieving and handling data with RemoteObject

8- Styling / Skinning

Não vamos nos esquecer que o Flex é uma tecnologia de interface e, como tal, certamente há expectativas em relação ao design. Como um desenvolvedor Flex, você deve ser capaz de personalizar a aparência de seus aplicativos usando estilos CSS, gráficos e/ou skins.

Com o Flex 4, não há mais desculpas. Use um pouco do seu tempo para conhecer de uma vez o lado direito do seu cérebro. É uma excelente mudança de paradigma, e vai ajudá-lo a diferenciar-se dos outros desenvolvedores Flex.

· Flex Style Explorer

· ScaleNine

· Introduction to Flex: Part 3 – Styles & Skins

9- Pelo menos um framework de arquitetura Flex

A maioria dos frameworks de arquitetura Flex impõe uma separação de camadas através da implementação do MVC (model-view-controller). Além disso, esses mesmos frameworks especificam como seu código deve ser organizado dentro do projeto Flex.

Embora muitos argumentariam que os frameworks são desnecessários, acredito que os desenvolvedores Flex se beneficiam em muitos aspectos da experiência de usá-los. Basta assistir ? s técnicas (boas ou más) empregadas por um framework para resolver problemas complexos de arquitetura. Isso contribuirá para seu crescimento como um desenvolvedor Flex.

Além disso, é difícil negar o fato de que a experiência com framework aumentará substancialmente o seu valor comercial como um desenvolvedor Flex. Jesse Warden me disse recentemente “Existem poucas empresas que não usam frameworks, mas isso é raro. Queiramos ou não, está na ‘moda’”. Eu concordo com Jesse.

· Cairngorm

· Parsley

· PureMVC

· Mate

· Swiz

· Robotlegs

10- Ciclo de vida de componentes e display list

Eu não estava convencido da necessidade de aprender o ciclo de vida de componentes Flex ou da display list até que escrevi o meu primeiro componente customizado (na verdade foi um componente semi-customizado que se estendia do componente Canvas). Até essa época eu usava componentes nativos do Flex, usando apenas o MXML enquanto que a display list era renderizada para mim. Em nenhuma vez tive que usar os métodos addChild, createChildren ou commitProperties, e usava o evento creatiomComplete para tudo.

Meu primeiro componente customizado usava uma quantidade enorme de eventos assíncronos, e eu não poderia prever a ordem em que cada evento seria disparado. Só depois que eu aprendi os métodos e variáveis do ciclo de vida dos componentes do Flex que eu pude ter um certo controle.

Estes métodos do ciclo de vida estão lá para serem usados. Saiba como funcionam e use-os para o seu benefício. Sua vida será mais fácil e você perderá menos cabelos.

· Colin Moock’s Lost ActionScript Weekend – The Display List

· Creating New Components in Flex 3

· Diving Deep with the Flex Component Lifecycle

· Understanding the Flex 3 Component and Framework Lifecycle

[1] Expressão americana usada para algo que requer pouco esforço mental ou inteligência para realizar ou compreender

Vamos a segunda parte. Para evitar o problema de perda de sessão ocasionado pelo Upload utilizando método upload da classe FileReference do Flex é preciso recuperar no Java o jsessionid.

public String getSessionId()
  // Pegando Request no blazeDS
  HttpServletRequest request = FlexContext.getHttpRequest();
  HttpSession session = request.getSession();

  return request.getSession().getId();

Já no Flex para utilizar o FileReference:

protected function btEscolher_clickHandler(event:MouseEvent):void
   if(fileRef == null)
    this.fileRef = new FileReference();
    this.fileRef.addEventListener(Event.SELECT, onSelect);
    this.fileRef.addEventListener(Event.COMPLETE, onUploadComplete);
    this.fileRef.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onErro);
    this.fileRef.addEventListener(IOErrorEvent.IO_ERROR, onErro);
    fileRef.addEventListener(ProgressEvent.PROGRESS, onProgress);

   this.fileRef.browse();
  }

Apenas é necessários realizar os tratamento para cada EventListener colocado.

Caso você não tenha lido a Parte I deste tutorial acesse aqui.

Segue um exemplo de como desenvolver um Servlet para upload de arquivos realizando a integração com Flex. Confira a solução adotada para resolver o problema de perda de sessão do upload com Flex nos browsers Firefox e Chrome.


Segue o código java:

package com.xxx.business.services;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import sun.misc.BASE64Decoder;

import com.xxx.commons.AccessProperties;
import com.xxx.core.exception.BusinessException;

public class ServletUploadFile extends HttpServlet {

 public ServletUploadFile() {
 }

 protected void doGet(HttpServletRequest request,
   HttpServletResponse response) throws ServletException, IOException {

  doPost(request, response);
 }

 protected void doPost(HttpServletRequest request,
   HttpServletResponse response) throws ServletException, IOException {
  try {
   // Verifica se é upload
   boolean isMultipart = ServletFileUpload.isMultipartContent(request);

   if (isMultipart) {
    FileItemFactory factory = new DiskFileItemFactory();

    ServletFileUpload upload = new ServletFileUpload(factory);

    List items = upload.parseRequest(request);

    Iterator iter = items.iterator();
    while (iter.hasNext()) {
     FileItem item = (FileItem) iter.next();

     if (item.isFormField()) {
      processFormField(item);
     } else {
      processUploadedFile(item, "arquivos");
     }
    }
   }

  } catch (Exception e) {
   e.printStackTrace();
   throw (new ServletException(e.getMessage()));
  }
 }

 private void processFormField(FileItem item) throws ServletException {
  String name = item.getFieldName();
  String value = item.getString();

  System.out.println("Item name: " + name + " ; value: " + value);
 }

 private void processUploadedFile(FileItem item, String caminho)
   throws Exception {
  String fileName = item.getName();

  AccessProperties prop = new AccessProperties();
  String path = prop.getCaminhoPadrao() + caminho + "/upload/";

  // Verifica a existencia da pasta e se não existir ja cria
  if (FileUtils.verificaSeExisteECriaPasta(path)) {
   File uploadedFile = new File(path + fileName);
   if (!uploadedFile.exists()) {
    uploadedFile.createNewFile();
   }
   item.write(uploadedFile);

  } else {
   throw (new BusinessException(
     "Não foi possível criar uma pasta no servidor para o arquivo do upload."));
  }
 }

}

Agora vamos ao Flex:

Note que passamos o atributo?jsessionid que é utilizado para a sessão não ser perdida.

public function executaUploadFTP( file:FileReference ):void{
   var mile:Number = new Date().getUTCMilliseconds();

   var params:URLVariables = new URLVariables();
   params.jsessionid = this.sessionId;
   params.cod = mile;

   var servletTarget:URLRequest = new URLRequest("/ServletUploadFile;jsessionid=" +
    this.sessionId + "?cod=" + mile);

   servletTarget.method = URLRequestMethod.POST;
   servletTarget.data = params;
   file.upload(servletTarget, "Filedata", true);

  }

Na ?Parte II será abordado como recuperar o?jsessionid?e a construção da Tela Flex com seus métodos de busca do arquivo a ser enviado entre outro detalhes.

Segue um exemplo de como desenvolver um Servlet para download de arquivos realizando a integração com Flex.

Vamos ao Servlet:

package com.xxx.business.services;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.agriness.produto31.business.db.entities.Usuario;
import com.agriness.produto31.business.dto.Arquivo;
import com.agriness.produto31.commons.AccessProperties;
import com.agriness.produto31.core.exception.BusinessException;
import com.agriness.produto31.recurso310003.business.services.ArquivoDownload;

public class ServletDownloadFile extends HttpServlet {

 private static final long serialVersionUID = -1783732558472851554L;

 @Override
 @SuppressWarnings("unchecked")
 protected void service(final HttpServletRequest request,
   final HttpServletResponse response) throws ServletException,
   IOException {

  ArquivoDownload arqDown = new ArquivoDownload();
  Arquivo arq = new Arquivo();
  arq.setNome(request.getParameter("nome"));
  arq.setExtensao(request.getParameter("extensao"));
  arqDown.setArquivo(arq);
  arqDown.setCaminho("/download/");

  PrintWriter printwriter = response.getWriter();

  if (arqDown.getArquivo().getNome().length() == 0) {
   response.setContentType("text/html");
   printwriter.println("Nome do arquivo inválido");
   printwriter.flush();
   printwriter.close();
   return;
  }
  if (arqDown.getCaminho() == null) {
   response.setContentType("text/html");
   printwriter.println("Caminho do arquivo inválido");
   printwriter.flush();
   printwriter.close();
   return;
  }
  File file = new File(arqDown.getCaminho()
    + arqDown.getArquivo().getNome());
  if (file == null) {
   response.setContentType("text/html");
   printwriter.println("Arquivo não pode ser lido");
   printwriter.flush();
   printwriter.close();
   return;
  }

  if (!file.exists() || !file.canRead() || file.isDirectory()) {
   response.setContentType("text/html");

   if (!file.exists())
    printwriter.println("Arquivo inexistente");
   else if (file.isDirectory())
    printwriter.println("O arquivo é um diretório");
   else
    printwriter.println("Arquivo não pode ser lido");

   printwriter.flush();
   printwriter.close();
   return;
  }

  response.setHeader("Content-Disposition", "attachment; filename = "
    + arqDown.getArquivo().getNome());
  response.setContentType("octet-stream");

  int BUFF_SIZE = 1024;
  byte[] buffer = new byte[BUFF_SIZE];
  response.setContentLength((int) file.length());
  FileInputStream fis = new FileInputStream(file);
  OutputStream os = response.getOutputStream();

  int byteCount = 0;
  try {
   do {
    byteCount = fis.read(buffer);
    if (byteCount == -1)
     break;
    os.write(buffer, 0, byteCount);
    os.flush();
   } while (true);
  } catch (Exception excp) {
   excp.printStackTrace();
  } finally {
   os.close();
   fis.close();
  }

 }
}

Segue o código Flex:

public function executaDownloadFromUrl( url:String ):void{
   if( url == null ){
    return;
   }
   var u:URLRequest  = new URLRequest(url);
   navigateToURL(u);
  }

Monte a url conforme os atributos definidos no Servlet.
ex: http://meudominio.com/Servlet/?nome=nomeArquivo&extensao=.pdf

Olá pessoal,

Depois de quase um ano afastado do blog estou voltando as suas atividades, e para recomeçar com o pé direito, resolvi dar uma cara nova ao espaço, espero que gostem deste novo theme. Meu último post foi referente ao FlexMania 2010, e volto agora postando sobre um novo evento, o Flash Camp Brasil 2011.

O Flash Camp Brasil aconteceu em Maceió durante os dias 8 e 9 de abril. Tive a oportunidade de participar de um workshop privado oferecido pela RIM sobre o Playbook na sexta-feira. O workshop durou o dia todo, e nele pudemos conhecer todo o ambiente de desenvolvimento para o PlayBook. O Workshop na parte Flex foi ministrado pelo Julian Dolce, Platform Lead na QNX Software Systems. Uma coisa que ficou muito clara durante o Workshop é que o PlayBook veio para ficar, com certeza o melhor tablet que já tive acesso.

Sobre as palestras não vou comentar uma a uma porque todas foram ótimas, mas fica a dica para quem vai assistir as gravações no youtube, na minha opinião não deixe de assistir as seguintes palestras:

• Status na Década de 10 – André Matarazzo;
• O futuro do Flash Runtime – Arno Gourdol
• Se aprofundando no Molehill, o futuro do Flash Player – Alex Karpovich
• Criando AIR Applications para TVs – Elad Elrom
• Flex em dispositivos móveis – Igor Costa
• ADHD FTW, Gargalhadas! – Grant Skinner

A organização foi perfeita, não vi nenhum problema durante o evento, algumas pessoas relataram alguma dificuldade com a tradução simultânea, mas na velocidade que os palestrantes falavam realmente era impossível uma tradução perfeita.

Também tive a oportunidade de conhecer pessoalmente o John Koch e o Leandro Reis da Adobe USA. Tivemos um bate-papo aonde eles puderam conhecer mais sobre o AUG FlexDuck, nosso trabalho junto a comunidade e nos orientar sobre nossas atividades, realmente foi excelente essa conversa.

E para finalizar, foi excepcional conhecer pessoalmente toda essa galera que faz parte da comunidade Flex no Brasil.

Parabéns Demian pelo esforço na organização!

Abaixo algumas fotos no evento

Flash Camp Brasil – Radisson Hotel

PlayBook Workshop

Stefan Horochovec, Igor Costa, Janderson, Jotaefe, Bruno Sales, Thalison, Thiago Felix, Mario Junior

Janderson, Jotaefe, Thalison, Igor Costa, Marcus Pinto, Stefan Horochovec, Mario Junior

John Koch, Stefan Horochovec, Leandro Reis

Stefan Horochovec, Arno Gourdol

Stefan Horochovec, Julian Dolce

Demian Borba, Stefan Horochovec

Sorteio

Leandro Reis, Stefan Horochovec, Fabiana GO, Jotaefe, Mauri Dengo, Leon, Lauro Santos

Um até breve a Maceió, no mais tardar, nos encontraremos em 2012 no próximo Flash Camp Brasil!

Olá a todos!

A Adobe lançou, esta semana, a versão 2.6 da sua framework AIR. Esta framework permite criar projectos que correm em cima do Flash Player e que permite o acesso a informações / interacções com o computador / dispositivo mobile do utilizador.

Aqui ficam vários links sobre tudo o que tem sido escrito sobre esta nova release, alguns tutoriais e ainda um jogo muito interessante:

• Everything new in Adobe AIR 2.6
• What’s new in Adobe AIR 2.6
• iOS Features in Adobe AIR 2.6
• Developing for iOS with AIR for Mobile 2.6
• “Comb Over” : An AIR 2.6 multiscreen game

?

Abraço e até à próxima!