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
