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
Sites de jogos online feitos com Adobe Flash se tornaram muito populares. Existem varias produtoras que se especializaram no desenvolvimento de jogos em Flash e nos últimos anos vimos um crescimento grande em relação aos jogos em Flash nas redes sociais a exemplos dos jogos casuais que encontramos no Facebook e Orkut.
