Dae pessoal.

Estou iniciando ainda no FX4 ou Flash Builder como queiram, então tenho minhas dificuldades ainda, mas é muito bom o resultado que estou vendo. Esse dias me deparei com alguns problemas com states que no Flex 3 eu fzia algo do tipo:

Fx3

<mx:State name="logonState">
	<mx:SetProperty target="{textInputNome}" name="visible" value="true" />

Bom as mudanças para o FX4 foram muitas onde no próprio componente adicionamos essas propriedades.
Logo no inicio fiquei de cara achava mais dificil sei la, mas achei que é algo que melhorou muito, ou seja,
sim ficou melhor ja me acostumei e achei mais “clean” o negocio.

veja o exemplo que fiz abaixo:
FX4

e o Codigo fica esse

xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx"
			   minWidth="955" minHeight="600"
			   currentState="state1" viewSourceURL="srcview/index.html">
	<fx:Declarations>
?
	fx:Declarations>
	<fx:Script>
		[CDATA[
			import mx.collections.ArrayCollection;
?
			import spark.events.IndexChangeEvent;
			[Bindable]
			private var arrayCollection:ArrayCollection=new ArrayCollection([
				{prop:'state1'},{prop:'state2'}]);
?
?
?
?
			protected function comboBox_changeHandler(event:IndexChangeEvent):void
			{
				this.currentState=comboBox.selectedItem.prop;
			}
?
		]]>
	fx:Script>
	<s:states>
		<s:State name="state1"/>
		<s:State name="state2"/>
	s:states>
	<mx:Form>
		<mx:FormItem>
			<s:TextInput id="textInput1" text.state1="FELIPE" text.state2="BORELLA"/>
		mx:FormItem>
		<mx:FormItem>
			<s:TextInput id="textInput2" text.state1="BORELLA" text.state2="FELIPE"/>
		mx:FormItem>
		<mx:FormItem>
			<s:ComboBox id="comboBox" labelField="prop" dataProvider="{arrayCollection}"
						change="comboBox_changeHandler(event)" selectedIndex="0"/>
		mx:FormItem>
	mx:Form>
s:Application>

Felipe!

Daeee galera!
Esse port é para mostra um Skin bacana que catei na internet.
Original em http://flexdevtips.blogspot.com/2010/07/spark-textarea-with-line-numbers.html

Vamos ao Skin:

xml version="1.0" encoding="utf-8"?>
<s:SparkSkin xmlns:fx="http://ns.adobe.com/mxml/2009"
			 xmlns:s="library://ns.adobe.com/flex/spark"
			 xmlns:mx="library://ns.adobe.com/flex/mx"
			 xmlns:fb="http://ns.adobe.com/flashbuilder/2009"
			 creationComplete="created(event)"
			 alpha.disabled="0.5"
			 blendMode="normal">
?
	<fx:Metadata>
		[CDATA[
		[HostComponent("spark.components.TextArea")]
		]]>
	fx:Metadata>
?
	<fx:Script fb:purpose="styling">
		private var lineBreakChanged:Boolean;
?
		private var paddingChanged:Boolean;
?
		private var verticalAlignChanged:Boolean;
?
		/* Define the skin elements that should not be colorized.
		For text area, the skin itself is colorized but the individual parts are not. */
		static private const exclusions:Array = ["background", "scroller"];
?
		/**
		 * @private
		 */
		override public function get colorizeExclusions():Array {
			return exclusions;
		}
?
		/* Define the content fill items that should be colored by the "contentBackgroundColor" style. */
		static private const contentFill:Array = ["bgFill"];
?
		/**
		 *  @private
		 */
		override public function get contentItems():Array {
			return contentFill
		}
		;
?
		/**
		 *  @private
		 */
		override protected function commitProperties():void {
			super.commitProperties();
?
			if (lineBreakChanged) {
				updateStringStyle("lineBreak");
				lineBreakChanged = false;
?
				if (textDisplay != null) {
					if (getStyle("lineBreak") == "explicit") {
						if (textDisplay.percentWidth == 100) {
							textDisplay.width = NaN;
						}
					} else if (textDisplay.percentWidth != 100) {
						textDisplay.percentWidth = 100;
					}
				}
			}
			if (paddingChanged) {
				updatePadding();
				paddingChanged = false;
			}
			if (verticalAlignChanged) {
				updateStringStyle("verticalAlign");
				verticalAlignChanged = false;
			}
		}
?
		/**
		 * @private
		 */
		override protected function initializationComplete():void {
			useChromeColor = true;
			super.initializationComplete();
		}
?
		/**
		 *  @private
		 */
		override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void {
			if (getStyle("borderVisible") == true) {
				border.visible = true;
				shadow.visible = true;
				background.left = background.top = background.right = background.bottom = 1;
				scroller.left = scroller.top = scroller.right = scroller.bottom = 1;
			} else {
				border.visible = false;
				shadow.visible = false;
				background.left = background.top = background.right = background.bottom = 0;
				scroller.left = scroller.top = scroller.right = scroller.bottom = 0;
			}
?
			borderStroke.color = getStyle("borderColor");
			borderStroke.alpha = getStyle("borderAlpha");
?
			super.updateDisplayList(unscaledWidth, unscaledHeight);
		}
?
		/**
		 *  @private
		 */
		private function updatePadding():void {
			if (!textDisplay)
				return;
?
			// Push padding styles into the textDisplay
			var padding:Number;
?
			padding = getStyle("paddingLeft");
			if (textDisplay.getStyle("paddingLeft") != padding)
				textDisplay.setStyle("paddingLeft", padding);
?
			padding = getStyle("paddingTop");
			if (textDisplay.getStyle("paddingTop") != padding)
				textDisplay.setStyle("paddingTop", padding);
?
			padding = getStyle("paddingRight");
			if (textDisplay.getStyle("paddingRight") != padding)
				textDisplay.setStyle("paddingRight", padding);
?
			padding = getStyle("paddingBottom");
			if (textDisplay.getStyle("paddingBottom") != padding)
				textDisplay.setStyle("paddingBottom", padding);
		}
?
		/**
		 *  @private
		 */
		private function updateStringStyle(styleName:String):void {
			if (!textDisplay)
				return;
?
			// Push style into the textDisplay
			var style:String;
?
			style = getStyle(styleName);
			if (textDisplay.getStyle(styleName) != style) {
				textDisplay.setStyle(styleName, style);
			}
		}
?
		/**
		 *  @private
		 */
		override public function styleChanged(styleProp:String):void {
			var allStyles:Boolean = !styleProp || styleProp == "styleName";
?
			super.styleChanged(styleProp);
?
			if (allStyles || styleProp.indexOf("lineBreak") == 0) {
				lineBreakChanged = true;
				invalidateProperties();
			}
			if (allStyles || styleProp.indexOf("padding") == 0) {
				paddingChanged = true;
				invalidateProperties();
			}
			if (allStyles || styleProp.indexOf("verticalAlign") == 0) {
				verticalAlignChanged = true;
				invalidateProperties();
			}
		}
	fx:Script>
?
	<fx:Script>
		[CDATA[
			import mx.events.FlexEvent;
?
			/**
			 * @private
			 */
			private static const focusExclusions:Array = ["textDisplay"];
?
			/**
			 *  @private
			 */
			override public function get focusSkinExclusions():Array {
				return focusExclusions;
			}
?
			protected function created(event:FlexEvent):void {
				updateLineNumbers(event);
				hostComponent.addEventListener(FlexEvent.UPDATE_COMPLETE, updateLineNumbers, false, 0, true);
			}
?
			private var _lines:int = 0;
?
			private function updateLineNumbers(event:Event):void {
				var lines:int = textDisplay.mx_internal::textContainerManager.numLines;
				if (lines != _lines) {
					var old:int = _lines;
					this._lines = lines;
					var diff:int = lines - old;
					var linesString:String;
					var i:int;
					if (diff > 0) {
						linesString = lineNumbersLabel.text;
						for (i = old + 1; i <= _lines; i++) {
							if (i > 1) {
								linesString += "n";
							}
							linesString += i.toString(10);
						}
					} else {
						linesString = "";
						for (i = 1; i <= _lines; i++) {
							if (i > 1) {
								linesString += "n";
							}
							linesString += i.toString(10);
						}
					}
					lineNumbersLabel.text = linesString;
				}
			}
		]]>
	fx:Script>
?
	<s:states>
		<s:State name="normal"/>
		<s:State name="disabled"/>
	s:states>
?
	
	
	<s:Rect id="border"
			bottom="0"
			left="0"
			right="0"
			top="0">
		<s:stroke>
			
			<s:SolidColorStroke id="borderStroke"
								weight="1"/>
		s:stroke>
	s:Rect>
?
	
	
	
		
			
			
		
	
?
	
	
	
		
			
		
	
?
	
	
		
			
				
			
			
			
				
					
				
			
			
				
					
				
			
		
?
		
			
			
		
	
?

E ao Uso do mesmo no componente

xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
			   xmlns:s="library://ns.adobe.com/flex/spark"
			   xmlns:mx="library://ns.adobe.com/flex/mx" width="100%" height="100%">
	<fx:Declarations>
?
	fx:Declarations>
?
	<s:TextArea width="400" height="200" skinClass="br.com.fborella.SkinTextArea">
	s:TextArea>
s:Application>

Lembre-se de colocar o arquivo no seu pacore e ajustar o mesmo no skinClass

Exemplo:

Abraço

Felipe

BlazeDS é uma aplicação Java opensource mantida pela Adobe, sob licensa GNU Lesser General Public License, Version 3 (LGPL v3), que fornece um conjunto de serviços, todos sobre o protocolo HTTP(Hyper Text Transfer Protocol), para permitir uma aplicação Flex fazer chamadas a serviços remotos Java, retornando os dados tanto de forma assíncrona como em tempo real.

Por utilizar o formato de dados binário chamado AMF(Action Message Format) para a serialiazação e deserialização de dados, a comunicação entre uma aplicação Flex e o servidor Web se torna muito otimizada. Existem estudos feitos comparando as diversas tecnologias, como o Jamesward, mostrando o potencial do AMF.

Outra grande vantagem quando usamos o BlazeDS é a facilidade de ter classe Java automaticamente convertida para uma classe ActionScript e vice-versa.

O BlazeDS pode ser baixado do site da Adobe em dois formatos:

1. Turnkey – Versão que já vem com exemplos e servidor tomcat pré configurado
2. Binary – Versão com os binários

Você pode optar também por fazer o download do código fonte. A documentação também está disponível neste link.


Entendendo os arquivos de configuração do BlazeDS
A estrutura de arquivos do BlazeDS é bem simples, quando descompactamos o blazeds.war, presente na versão binária, podemos ver a seguinte estrutura:

Devemos nos atentar a duas pastas. A pasta lib, que contém todos os jars necessários, e a pasta flex, que contém todos os arquivos de configuração do BlazeDS. Vamos ver o que cada arquivo significa:

1. services-config.xml: É neste arquivo que estão as principais configurações do BlazeDS como segurança, logging, serviços disponíveis (Canais), fábricas para a integração com Frameworks Java como Spring e EJB3 e as referências para os outros três arquivos de configuração.
2. remoting-config.xml: É nesse arquivo que iremos configurar os serviços Java para serem “consumidos” pela aplicação Flex. Sempre quando configuramos este arquivo, iremos trabalhar com o componente Flex chamado RemoteObject.
3. message-config.xml: Aqui é configurado tudo o que for relacionado com mensageria, sempre necessário quando trabalhamos com os componentes Flex Consumer e Producer. Um exemplo da utilização desta tecnologia seria fazer um bate bapo, ou até mesmo aplicações colaborativas, onde é desejável a iteração simultânea de diversos usuários.
4. proxy-config.xml: Além da possibilidade de utilizarmos o componente RemoteObject, o Flex disponibiliza mais duas formas de integração: O HTTPService e o WebService. Porém, por questões de segurança, os serviços só podem ser chamados quando os mesmos estão no mesmo domínio que a aplicação, ou que exista uma configuração específica que permita um cliente Flex fazer a consulta (esta configuração é feita por um arquivo chamado crossdomain.xml e está sempre no servidor onde está o serviço chamado). Caso uma das duas condições acima não seja satisfeita, deveremos utilizar o BlazeDS como proxy , e é ai que configuração deste arquivo se torna necessário.

Criando o seu primeiro projeto com o BlazeDS

Para criar o projeto iremos precisar de:

1. Eclipse Galileo JEE
2. FlashBuilder Plugin
3. BlazeDS 4 Binary
4. Tomcat 6

Feito os downloads e a instalação do Eclipse e FlashBuilder, vamos iniciar o FlashBuilder para criar o projeto.
Antes de criar o projeto, vamos configurar o Tomcat:

1. Nas preferências do Eclipse, vá em Server — Runtime Environments e clique em Add…
   
2. Na pasta Apache selecione Apache Tomcat v6.0 e clique em Next
   
3. Selecione a pasta onde você descompactou o Tomcat e clique em Finish
   

Feito a configuração do Tomcat, vamos criar o projeto:

1. Vá em File – New – Flex Project
2. Preencha os dados do primeiro passo como na imagem abaixo e clique em Next
   
3. Neste passo vamos configurar os dados do servidor. Deixe tudo configurado como na imagem e clique em Next
   
   
   Para selecionar o “Target Runtime”, clique em New e depois escolha o Apache Tomcat 6, como na imagem abaixo.
   
4. No último passo não será necessário mudar nada, clique em Finish
   

Agora vamos criar a classe Java que terá o serviço para retornar a string “HelloBlazeDS”

1. Crie uma classe Java br.com.dclick.service.RemotingService
   
2. Crie o serviço:

   1 2 3 4 5 6 7 8

   package br.com.dclick.service; public class RemotingService { ? ? public String sayHello() { ? ? ? ? return “HelloBlazeDS”; ? ? } ? ? }

Agora vamos configurar o BlazeDS para disponibilizar o serviço que acabamos de criar.

1. Abra o arquivo remoting-config.xml que está na pasta WebContent/WEB-INF/flex
2. Para que seja possível chamar os métodos da classe Java, precisamos configurar um destination. Isso é necessário para cada classe Java.
   O arquivo fica assim:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   xml version=“1.0″ encoding=“UTF-8″?> “remoting-service” class=“flex.messaging.services.RemotingService”> ? ? ? ? ? ? “java-object” ? ? ? ? ? ? class=“flex.messaging.services.remoting.adapters.JavaAdapter” ? ? ? ? ? ? default=“true” /> ? ? ? ? ? ? ? ? “my-amf” /> ? ? ? ? “blazeServices”> ? ? ? ? ? ? ? ? ? ? br.com.dclick.service.RemotingService ? ? ? ? ? ?

Vamos colocar na aplicação a chamada para o servidor.

1. A primeira coisa que precisamos fazer é configurar o RemoteObject. Fazer isso é muito simples:

   1 2 3 4 5

   ? ? ? ? ? ? ? ? “services” destination=“blazeServices” ? ? ? ? ? ? ? ? ? ? ? ? result=“services_resultHandler(event)” ? ? ? ? ? ? ? ? ? ? ? ? fault=“services_faultHandler(event)” /> ? ?

   
   Alguns detalhes:
   
   * Perceba que a propriedade destination aponta para o destination que configuramos no arquivo remoting-config.xml
   
   * Precisamos declarar um id para poder referenciar o RemoteObject
   
   * Adicionamos um ResultHandler para tratar o resultdo do serviço
   
   * Adicionamos um FaultHandler para tratar a falha do serviço

2. Os Handlers ficam assim:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   ? ? ? ? ? ? ? ? [CDATA[ ? ? ? ? ? ? import mx.controls.Alert; ? ? ? ? ? ? import mx.rpc.events.FaultEvent; ? ? ? ? ? ? import mx.rpc.events.ResultEvent; ? ? ? ? ? ? protected function services_resultHandler(event:ResultEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? Alert.show(event.result.toString()); ? ? ? ? ? ? } ? ? ? ? ? ? protected function services_faultHandler(event:FaultEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? Alert.show(event.fault.message); ? ? ? ? ? ? } ? ? ? ? ]]> ? ?

   
   Alguns detalhes:
   
   * A propriedade result do evento ResultEvent vai conter o resultado do serviço. No nosso caso o serviço retorna uma String “HelloBlazeDS”
   
   * A propriedade fault do evento FaultEvent contém os detalhes do erro.

3. A última coisa é chamar o serviço. Vamos fazer isso no evento creationComplete, como segue:

   1 2 3 4

   ? ? ? ? protected function application1_creationCompleteHandler(event:FlexEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? services.sayHello(); ? ? ? ? ? ? }

4. A aplicação inteira fica assim:

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   ? ? ? ? xml version=“1.0″ encoding=“utf-8″?> “http://ns.adobe.com/mxml/2009″ ? ? ? ? ? ?? ? xmlns:s=“library://ns.adobe.com/flex/spark” ? ? ? ? ? ?? ? xmlns:mx=“library://ns.adobe.com/flex/mx” minWidth=“955″ minHeight=“600″ ? ? ? ? ? ?? ? creationComplete=“application1_creationCompleteHandler(event)”> ? ? ? ? ? ? [CDATA[ ? ? ? ? ? ? import mx.controls.Alert; ? ? ? ? ? ? import mx.events.FlexEvent; ? ? ? ? ? ? import mx.rpc.events.FaultEvent; ? ? ? ? ? ? import mx.rpc.events.ResultEvent; ? ? ? ? ? ? protected function services_resultHandler(event:ResultEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? Alert.show(event.result.toString()); ? ? ? ? ? ? } ? ? ? ? ? ? protected function services_faultHandler(event:FaultEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? Alert.show(event.fault.message); ? ? ? ? ? ? } ? ? ? ? ? ? protected function application1_creationCompleteHandler(event:FlexEvent):void ? ? ? ? ? ? { ? ? ? ? ? ? ? ? services.sayHello(); ? ? ? ? ? ? } ? ? ? ? ]]> ? ? ? ? ? ? ? ? “services” destination=“blazeServices” ? ? ? ? ? ? ? ? ? ? ? ? result=“services_resultHandler(event)” ? ? ? ? ? ? ? ? ? ? ? ? fault=“services_faultHandler(event)” /> ? ?

Agora só falta fazer o deploy da aplicação e subir o servidor.

1. Vá em Window – Show View – Other. Na janela que abrir, digite Servers e clique OK
   
2. Na view Servers, clique com o botão direito em Tomcat v6.0 e selecione Add and Remove…
3. Selecione a aplicação HelloBlazeDS e clique em Add e depois Finish
   
4. Na view Servers, clique com o botão direito em Tomcat v6.0 e clique em Run

Agora é só executar a aplicação e ver o resultado:

Isso é tudo, guarde esse projeto configurado para ser usado nos próximos posts.

Neste post vou explicar como usar a API de Log para mostrar os logs de execução da aplicação e também como usar o componente TraceTarget, que é muito útil para poder recuperar as informações das chamadas para o servidor, facilitando a resolução de problemas.

No Flex temos duas opções para recuperar informações ou logs de execução de uma aplicação. Uma primeira maneira e a mais utilizada, é usar a função global trace(”) para mostrar informações no console do FlashBuilder. Essa abordagem sempre requer que a aplicação esteja sendo executada em modo de debug, o que exige a instalação de um FlashPlayer versão de debug. Lógico que para o ambiente de desenvolvimento isso não é um problema, já que a instalação do FlashBuilder já inclui a versão correta do FlashPlayer versão debug. Mais e quando a aplicação está em produção, ou seja, quando não contamos com a versão de debug do FlashPlayer? Ai que entra a segunda opção.Na segunda opção vamos usar a API de Logging do Flex, que vai nos permitir delegar para uma classe a função de logar informações, seja usando o trace(”), primeira abordagem, ou até mesmo customizando a forma de apresentação. Esta abordagem também nos permite controlar o que é exibido, utilizado categorias e nível de log.

A API de Logging do Flex é muito simples de ser usada. Toda vez que queremos usa-la, estaremos envolvendo duas partes:

1. O Logger, que possui os meios para enviar informações em diversos níveis (all, debug, info, warn, error e fatal) em uma determinada categoria para o Log Target. O Logger sempre irá implementar a interface ILogger, iremos utilizar a classe mx.logging.LogLogger, que já vem no SDK;
2. O Log Traget, que será responsável por registrar a informação usando o trace(”) ou outra implementação. Iremos utilizar a classe mx.logging.targets.TraceTarget.

Para ficar mais fácil de entender como usar a API, vamos imaginar que queremos logar quando a aplicação é pré-inicializado, inicializado e criado.Inicialmente iremos usar a função global trace(”) e depois usar as classes de Log.

Ler o resto…

Durante o ando de 2010 diversos leitores me escreveram solicitando alguma forma de “receita de bolo” para a criação de projetos em Flex. Estavam buscando uma maneira de criar uma aplicação de forma que fosse mais correta e mais fácil, baseada em padrões de projeto e definida através de uma estrutura que facilitasse o desenvolvimento.

No início de 2011 comecei a pensar mais no assunto, pois irei implementar estas regras nos próximos livros, chegando a uma série de “regras” das quais estarei apresentando neste artigo. Inicialmente, queria dizer que eu não sou o dono da verdade, e estou longe de criar alguma regra que se não usada irá causar o seu insucesso. Estou disposto a receber críticas que sejam construtivas, com o intuito de melhorar o sistema cada vez mais, possibilitando assim que a comunidade tenha em mãos um bom documento para consulta.

PHP ou Java?

Uma das perguntas que mais recebi ao longo de 2010, por isso estarei discutindo um pouco sobre qual linguagem de servidor usar. Inicialmente você deve saber que não é a linguagem que vai fazer você ter sucesso ou não em um sistema, e sim o quanto você conhece a mesma. Por exemplo, se você conhece muito bem PHP, porque aventurar-se em Java se dá conta do recado? O mesmo vale para o Java, mas não recebi emails de nenhum programador Java querendo mudar para php… (sic.. hehe).

O que? é fato nesta “briguinha” é que, não existe melhor ou pior. Java é mais complexo que php, exige mais atenção mas traz muitos benefícios, até financeiros (sim você ganha mais). PHP é mais fácil, você cria tudo mais rápido e com isso fica mais feliz Qual você vai escolher? Escolha a que te faz mais feliz.

Zend_AMF ou AMFPHP ?

Outra dúvida muito comum entre os programadores PHP. Eu costumo selecionar um ou outro dependendo do projeto em sí. Se o seu projeto vai usar alguns recursos do Zend Framework, e são muitos, utilize o Zend_AMF. Caso contrário, use AMFPHP.? Aqui chegamos a um impasse do qual julgo ser mais importante do que a briga entre Zend e AMFPHP: você ainda pensa em criar um projeto sem o Zend Framework? Você irá criar tudo que precisa “na mão” ou vai usar componentes de terceiros? Falo isso porque se um projeto em PHP é iniciado, o uso do Zend Framework irá acelerar muito o processo do mesmo. Rotinas como enviar email, acessar a sessão do php, gerenciar usuários com ACL, persistência de dados, acesso ao twitter… são todos muito bem implementados com o Zend e o Zend Framework é mantido pela mesma empresa que mantém o PHP, então não existe biblioteca mais segura em termos de continuidade do que esta.

E quais tecnologias vamos usar nas “melhores práticas” ?

Agora que discutimos as duas perguntas mais perguntadas em 2010 vamos a esta solução que julgo, pessoalmente, ser muito boa:

No cliente:

• Adobe Flash Burrito e Flex SDK 4.5 (Basta baixar e instalar o Flash Burrito: http://labs.adobe.com/technologies/flashbuilder_burrito/).
• SWIZ Framework (http://swizframework.org/)

No servidor:

• PHP
• Zend Framework (http://www.zend.com/community/downloads)
• WAMP Server (para rodar o PHP na própria máquina – http://www.wampserver.com/en/download.php)
• Netbeans ou Eclipse PDT – Eu estou gostando mais do Netbeans, então vou usá-lo.? (http://netbeans.org/downloads/index.html? – Versão PHP)

?

Certifique-se de ter tudo instalado, para que possamos dar prosseguimento no artigo.

Estrutura de pastas e projetos

Outra dúvida comum dos usuários, é definir a estrutura de pastas do projeto. Como instalamos o WAMP Server, ele nos fornece uma pasta onde é possível ter acesso pelo nacegador, através do endereço “localhost”. Isto é, ao acessarmos http://localhost/ o WAMP Server cuida de apontar para o diretório c:wampwww (que é o que chamamos de “document root”). Para que possamos entender a estrutura do projeto, é necessário compreender uma particularidade do Flex. Diferentemente do PHP, os arquivos que estão dentro do projeto Flex não precisam ser enviados ao servidor (os arquivos mxml, as, etc). veja que o Flex compila todos os mxml/as do projeto e gera um único arquivo swf. Este arquivo sim DEVE estar no diretório web do projeto!

Vamos então criar o projeto “melhoresPraticas” da seguinte forma:

1. Crie a pasta c:wampwwwmelhoresPraticas Este é o diretório público do projeto, acessado através de http://localhost/melhoresPraticas?????????
2. Crie a pasta c:wampwwwmelhoresPraticasclasses Este é o diretório onde iremos criar as nossas classes PHP
3. Crie a pasta c:wampwwwmelhoresPraticasvos Este é o diretório onde as classes VOs serão criadas
4. Crie a pasta c:wampwwwmelhoresPraticasZend Aqui você copia/cola o Zend framework, de forma que o arquivo melhoresPraticasZendLoader.php esteja acessível
5. No Flash Builder, crie o projeto “melhoresPraticas”. Você pode deixar o DefaultLocation como está. Não clique em Finish, clique em Next, até chegar na configuração do “Compiled Flex application location”. Ou seja, aqui você irá informar para onde os aquivos compilados do flex irão ficar. Coloque o seguinte caminho: c:wampwwwmelhoresPraticasbin-debug. Não clique em Finish, clique em Next, e em Library Path, adicione a biblioteca swiz (o arquivo swc). Em “Output folder URL”, coloque: http://localhost/melhoresPraticas/bin-debug
6. Com o projeto pronto, clique no botão RUN. Deve então surgir uma página em branco no endereço: http://localhost/melhoresPraticas/bin-debug/melhoresPraticas.html
7. No Netbenas ou no eclipse, crie o projeto php apontando para c:wampwwwmelhoresPraticas

Testando a conexão

Com os projetos prontos, iremos inicialmente realizar uma simples conexão entre o Flex e o PHP. Isso é útil para que possamos começar com trabalho “pesado”. Para conectarmos o Flex no PHP, preciamos criar uma classe de conexão no Flex, que iremos chamar de ServiceBase, e um arquivo que recebe esta conexão no PHP, que chamaremos de gateway.php.

Para criar a classe ServiceBase, use o Flash Builder e acione o menu File > New > ActionScript Class e crie a classe de acordo com a imagem a seguir:

Classe ServiceBase:

package services
{
??? import mx.controls.Alert;
??? import mx.rpc.events.FaultEvent;
??? import mx.rpc.remoting.RemoteObject;
???
??? public dynamic class ServiceBase extends RemoteObject
??? {
??????? public function ServiceBase(classe:String)
??????? {
??????????? super(“zend”);
???????????
??????????? /*
???????????? * Como o arquivo swf está na pasta bin-debug,?
???????????? * precisamos subir um nível para chegarmos ao
???????????? * arquivo gateway.php
???????????? */
??????????? this.endpoint = “../gateway.php”;
???????????
??????????? this.source = classe;
??????????? this.addEventListener(FaultEvent.FAULT,OnFault);
??????? }
???????
??????? protected function OnFault(e:FaultEvent):void
??????? {
??????????? Alert.show(e.fault.faultString,”Erro” );
??????? }
??? }
}

Esta classe tem como principal objetivo estabelecer o endpoint, que é o gateway.php que ainda vamos criar. O atributo source define qual a classe que iremos acessar na pasta classes. Também adicionamos um listener genérico caso haja alguma falha na conexão. Veja que a classe é dinâmica (dynamic), ou seja, podemos chamar métodos da classe sem que eles estejam implementados na classe. Isso é útil pois os métodos chamados nesta classe serão os métodos remotos do PHP.

No servidor, temos que criar o arquivo gateway.php, com o seguinte código:

//Adiciona o autoloader do Zend Framework
// Assim todas as classes do framework
//? serão carregadas quando precisarem
require_once “Zend/Loader/Autoloader.php”;
Zend_Loader_Autoloader::getInstance()->setFallbackAutoloader(true);

//Instancia o servidor Zend_AMF
$server = new Zend_Amf_Server();

//Habilita o modo de desenvolvimento, retornando
// mensagens de erro. Comente esta linha quando
//?? estiver em modo de produção
$server->setProduction(false);

//Adiciona este diretorio como um diretorio de
// classes que podem ser usadas pelo Flex
$server->addDirectory(dirname(__FILE__).”/classes”);
set_include_path(dirname(__FILE__).”/vos”);

//TODO: Adicionar VOs

//Dependendo da requisição do Flex, irá
// chamar a classe correspondente, respondendo
//?? em formato AMF o que a classe responder.
echo $server->handle();

//Não fechar a tag PHP, nunca !!

?

O arquivo gateway.php é o ponto de entrada para as classes em PHP. Veja que inicialmente fazemos um include do Autoloader.php para que todas as classes do Zend Framework sejam instanciadas sem a necessidade de realizar requeires. Criamos então a instância do Zend_AMF_Server, que irá cuidar para que o flex consiga conversar com o PHP via AMF. Adicionamos o diretório classes como um diretório do AMF, onde as classes serão expostas ao flex e usamos o set_include_path para adicionar as classes que estão na pasta “vos” no path global do php, para que não precisamos fazer include das mesmas. Depois adicionaremos mais código sobre as classes VOs.

Na pasta “classes”, criamos a classe Teste, e o método sayHelloWorld. O nome do arquivo tem que ser o mesmo nome da classe, ou seja, Teste.php.

class Teste {
??? public function sayHelloWorld($name)
??? {
??????? return “Hello World $name”;
??? }
}

//Não feche a tag PHP!

?

Agora voltaremos ao Flex para que ele possa acessar a classe teste. No arquivo melhoresPraticas.mxml, adicionamos o seguinte código:

?

http://ns.adobe.com/mxml/2009″
?????????????? xmlns:s=”library://ns.adobe.com/flex/spark”
?????????????? xmlns:mx=”library://ns.adobe.com/flex/mx” minWidth=”955″ minHeight=”600″>
???
??????? ??????????? import mx.controls.Alert;
??????????? import mx.rpc.events.ResultEvent;
???????????
??????????? import org.swizframework.utils.services.ServiceHelper;
???????????
??????????? import services.ServiceBase;
??????? ]]>
???
???
???
??????? ???????????
??????????? var testeService:ServiceBase = new ServiceBase(“Teste”);
??????????? var serviceHelper:ServiceHelper = new ServiceHelper();
???????
??????? serviceHelper.executeServiceCall(
??????????? testeService.sayHelloWorld(“Daniel”),
??????????? function(e:ResultEvent):void{
??????????????? Alert.show(e.result.toString());
??????????? });
???????
??????? ]]>
???
???

?

Como estamos realizando um teste, fazemos o acesso ao PHP no evento creationComplete da aplicação. Criamos a variável testeService que é do tipo ServiceBase, repassando o parâmetro que é o nome da classe no PHP, ou seja, “Teste”. Também criamos a variável serviceHelper que pertence ao Swiz e é um facilitador de acessos ao PHP. Usamos no serviceHelper? o método executeServiceCall, que irá chamar remotamente o método sayHelloWorld repassando o parâmetro “Daniel” e quando concluído, executará a função que está no segundo parâmetro, realizando um Alert.

Ao executar esta aplicação, quando é carregada surgirá a mensagem de retorno do PHP:

?

Criando as classes em Service

Com o teste de conexão realizado, podemos avançar mais no código! A primeira refatoração que faremos é em relação as classes que estão na pasta service. Até agora criamos o seguinte código:

??? var testeService:ServiceBase = new ServiceBase(“Teste”);

Ao invés de criar a instância de ServiceBase repassando uma string que é o nome da classe, iremos criar a classe TesteService, da seguinte forma:

package services
{
??? public dynamic class TesteService extends ServiceBase
??? {
??????? public function TesteService()
??????? {
??????????? super(“Teste”);
??????? }
??? }
}

Veja que, ao criarmos a classe TesteService, podemos alterar o código da aplicação principal da seguinte forma:

var testeService:TesteService = new TesteService();

Implementando o SWIZ

Um dos melhores benefícios que o SWIZ traz é a possibilidade de separar todo o código Flex em camadas, assim como é feito no padrão MVC. Se você ainda não conhece SWIZ, é melhor conhecer, pois se está lendo este artigo está procurando criar aplicações com uma qualidade melhor e não há como chegar a esse nível sem um framework. O Swiz é o o melhor em termos de custo/benefício, porque nao é o mais fácil de aprender nem o mais complicado, e nao é o mais simples e nem o mais completo. É o meio termo em tudo.

Para usarmos o SWIZ, preciamos estabelecer algumas pastas dentro do projeto Flex, que serão nossas camadas. São elas:

• config: contém os arquivos que chamamos de “bean”, que são os arquivos que fornecem informações para serem injetadas em outras classes
• controllers: contém os arquivos que “ditam” a dinamica da camada de visualização
• services: contém os arquivos que fazem o acesso ao PHP
• events: contém eventos que podem ser disparados e mediados pelo flex
• valueObjects: são os VOs que iremos usar na aplicação
• views: contém os formúlários, é a camada de visão

Na pasta config, iremos criar o arquivo Bean.mxml, com o seguinte código:

??? xmlns:fx=”http://ns.adobe.com/mxml/2009″
??? xmlns:s=”library://ns.adobe.com/flex/spark”
??? xmlns:swiz=”http://swiz.swizframework.org”
??? xmlns:services=”services.*”
??? >
???
???
???

?

Neste bean, criamos a variável “testeService”, que é o tipo TesteService. Atenção quando ao uso de letras maiúsculas e minúsculas.? Sempre voltaremos no Bean.mxml para adicionar mais variáveis e com isso, injetá-las nos formulários e controllers da aplicação. Precisamos ainda configurar o Swiz no projeto principal da aplicação (melhoresPraticas.mxml):

http://ns.adobe.com/mxml/2009″
?????????????? xmlns:s=”library://ns.adobe.com/flex/spark”
?????????????? xmlns:mx=”library://ns.adobe.com/flex/mx”
?????????????? xmlns:swiz=”http://swiz.swizframework.org”
?????????????? minWidth=”955″ minHeight=”600″ xmlns:config=”config.*”>
???
???
???????
???????????
???????????????
???????????
???????????
???????????
??????????????? ??????????????????? eventPackages=”events.*”
??????????????????? viewPackages=”views.*”
??????????????????? />
???????????
???????????
???????????
???????????????
???????????
???????????
???????
???

???

?

Esta configuração, adicionada dentro do fx:Declarations, realiza uma configuração padrão no SWIZ. Basicamente adicionamos o Bean que criamos e definimos onde as classes relacionadas a eventos e formulários ficarão. Também definimos um LOG que será apresentado na aba Console do Flex se estiver rodando em modo de Debug.

Após a configuração

Podemos por exemplo criar a tela de login, e outras telas do sistema. Deixarei o código fonte da aplicação para que você possa olhar com calma.

Pegue o código fonte aqui

Conclusão

A lista a seguir é um resumo de melhores práticas que julgo importantes

• Use módulos/sub applications somente se precisar mesmo. Não comece um projeto de 10 telas querendo usar módulos para cada tela.
• Separe sua aplicação em camadas. Você escreve mais e cria mais artigos, mas o projeto fica mais consistente.
• Você não precisa criar o arquivo services-config.xml para conectar sua app no servidor. Pode-se criar uma classe cujo o endpoint é um caminho RELATIVO ao gateway.
• Use o caminho RELATIVO sempre, para faclitar o deploy da sua app. Isto é, use “../gateway.php” ao invés de “http://localhost/gateway.php”.
• Injete o controller na view, para passar dados à ela. Se deseja enviar mensagens para a view, então use eventos
• Não injete a view no controller.
• Use o dispatcher do SWIZ.
• Use o serviceHelper do SWIZ.
• Quando criar um formulário na view, faça o databind com uma variável do controller.
• Use eventos com moderação. Particularmente eu uso os eventos para notificar a view de alguma mudança, nunca para passar dados, que é função do controller.
• Se você quer chamar um método da view pelo controller, use eventos.
• Mais?

Neste tutorial vou criar uma pequena aplicação utilizando o Expression Blend 4,  será implementado o básico para quem está começando com o desenvolvimento de projetos para o Windows Phone 7 utilizando o Expression Blend 4.

No artigo anterior, vimos como preparar o ambiente gratuito de desenvolvimento para criar aplicações mobile utilizando o Windows Phone 7, o Expression Blend é instalado junto com o Windows Phone Developer Tools, saiba mais em Introdução ao Windows Phone 7.

Se você ainda não conhece o Expression Blend 4, talvez tenha uma dúvida, quando utilizar o Visual Studio 2010 e quando utilizar o Expression Blend ?

Tudo que é produzido em XAML pelo Expression Blend também pode ser reproduzido no Visual Studio 2010, porém, a criação de aplicativos visualmente ricos com as novas tecnologias trouxe novas possibilidades ao programador, como o suporte a elementos multimídias e animações, a possibilidade de modificar como as informações são apresentadas nos elementos visuais e outros diversos recursos, com isso houve a necessidade de ter uma ferramenta voltada ao designer da aplicação, onde o foco seria a camada visual.

O Expression Blend chegou para suprir essa necessidade, dessa forma o designer da aplicação tem uma ferramenta com recursos mais sofisticados e visuais, com o Blend a maioria das tarefas são executadas de forma visual, sem que seja necessário digitar dezenas de códigos, por exemplo, o Expression Blend tem total suporte a criação de animações, possuindo uma timeline, onde o designer poderá acionar a animação e gravar todos os movimentos que fizer com o mouse na aplicação, quando finalizar, todo o código XAML é gerado automaticamente pelo Blend, esse é somente um exemplo do qual a ferramenta gera produtividade quanto à criação visual da interface.

O Expression Blend é totalmente integrado ao Visual Studio 2010, é possível trabalhar com as duas ferramentas abertas com o mesmo projeto, que as modificações são atualizadas em cada ferramenta.

Criando uma aplicação no Expression Blend

A aplicação do tutorial vai listar algumas urls em um ListBox, quando o usuário clicar em um item, a aplicação será redirecionada para outra página em XAML, essa página vai  conter um browser e receberá o link a ser carregado.

Inicie o Expression Blend e crie uma aplicação do tipo Windows Phone Application, Figura 1, na aba Projects, temos os arquivos iniciais da aplicação gerados pelo Expression Blend, a aplicação tem três arquivos de imagens, e dois arquivos do tipo XAML, o XAML (eXtensible Application Markup Language), é uma marcação similar a marcação XML, é utilizada no Silverlight tanto para aplicações WEB como para o WP7, e também é utilizada para criar aplicações desktop com o WPF para o ambiente Windows.

Com a marcação XAML podemos criar layouts de telas separadas do código da linguagem de programação C#, possibilitando assim, um menor acoplamento entre o design e a programação, dessa forma um designer poderia trabalhar no design das telas utilizando somente o XAML, enquanto o programador faz o modelo da aplicação.

Resumidamente o arquivo App.xaml é usado pela aplicação silverlight para declarar recursos compartilhados no projeto, já o arquivo MainPage.xaml é o arquivo principal da aplicação, sua representação visual é a que aparece no centro da tela, mostrando uma interface com um layout inicial de um aplicativo WP7.

Figura 1 – Windows Phone Application

Layout Control

Na aba Objects and Timeline, temos a hierarquia dos elementos visuais da aplicação, em nosso projeto, inicialmente vemos 3 itens, o PhoneApplicationiPage, que é a pagina principal do layout, onde todos os elementos serão inseridos, o ApplicationBar, é uma área reservada para um barra onde podemos personalizar botões e menus para serem usados na aplicação, em seguida temos o LayoutRoot, este é o nome dado ao Layout Control Grid da aplicação default.

Um Layout Control serve para auxiliar no posicionamento de elementos na tela, existem vários controles de layout disponíveis em Silverlight, cada layout control tem sua utilidade dependendo do objetivo, o layout control Grid é um dos mais flexíveis, semelhante a uma tabela HTML, esse controle permite que seja criado linhas e colunas,  além de definir o tamanhos e a altura de cada linha e coluna.

Abaixo segue os tipos de Layouts disponíveis para serem utilizados no Windows Phone 7:

• Grid – Layout mais flexível , é possível inserir os elementos dentro de linhas e colunas.
• Canvas – permite posicionar os elementos em posições fixas dentro do Layout Control, ou seja, você pode definir uma posição exata que o elemento deve ficar no Canvas, fornecendo suporte ao posicionamento absoluto dos elementos filhos.
• StackPanel – Adiciona os elementos em uma pilha, com orientação vertical ou horizontal.
• ScrollViewer – Habilita barras de rolagens vertical e horizontal
•  Border – Insere uma borda em um único elemento interno.

 Veja neste link os Layout Controls na prática, para facilitar o entendimento eu digitei o código XAML abaixo da tela principal, refletindo as modificações, conforme digitadas. (video wmv ).

Conhecendo o MainPage.xaml

A tela inicial da aplicação contém um layout Grid principal, chamado de LayoutRoot , com um fundo transparente. Em seguida temos a definição de duas linhas dentro do layout. Dentro do layout control Grid chamado LayoutRoot temos outro layout control do tipo StackPanel, note que o StackPanel está definido na linha zero do Layout Control Grid acima, utilizando a propriedade Grid.Row = ”0”. Dentro do Stackpanel temos três elementos, um TextBlock chamado ApplicationTitle, onde na propriedade Text você poderá modificar o nome da aplicação para qualquer nome que desejar , em seguida temos outro TextBlock com nome de PageTitle, onde podemos também na propriedade Text  modificar o título da página. O Terceiro elemento é outro Layout Control do tipo Grid com o nome de ContentPanel, é nele que o conteúdo da sua aplicação será criado no projeto.

Listagem 1. XAML do código default

Mas tudo isso não é uma regra, em nossa aplicação de exemplo queremos aproveitar o máximo da tela do Windows Phone 7, vamos remover todo o conteúdo do primeiro layout Grid, o LayoutRoot, em seguida troque o tipo de layout, para isso, selecione com o botão direito do mouse no layout control e em Objects and Timeline, clique em Change Layout Type, Figura 3, e altere para um StackPanel. Adicione um ListBox no StackPanel,  o código completo está na Listagem 2.

Vamos também remover a barra do system tray do WP7, onde aparece o nível da bateria, sinal e hora, para isso, selecione o item PhoneApplicationPage na aba Objects and Timeline e nas propriedades, remova o checkbox Show SystenTray, Figura 2, com isso temos todo o espaço disponível da tela para utilizar em uma aplicação.

Figura 2 – Removendo o SystemTray

Figura 3 – Alterando o Layout Control

Listagem 2. XAML da aplicação

Inserindo dados de exemplo

Para criar o nosso exemplo seria necessário carregar informações de algum provedor de dados, o designer da aplicação não precisa conhecer como esses dados serão implementados, pois o ideal é que eles sejam ligados de forma menos acopladas possível, ou seja, que cada camada tenha suas responsabilidades bem definidas, para facilitar essa tarefa ao designer, e para auxiliar nos testes de dados em interfaces XAML, o Expression Blend disponibiliza uma forma de criar dados de exemplo,  deixando ainda os elementos visuais corretamente ligados as objetos que contém os dados.

Para criar uma coleção de dados de exemplo e ligar ao ListBox , clique na aba Data e no ícone Create Sample Data, digite o nome do DataSource, clique nas propriedades e modifique conforme desejar, depois arraste e solte a coleção para dentro do ListBox e você terá uma ListBox ligada a uma coleção de dados. Como esse passo é 100% visual no Expression Blend, veja neste vídeo rápido o processo passo a passo.

 ( video wmv) – Create Sample Data

Figura 4 – ListBox com dados de exemplo

Navegação de Páginas

Para finalizar o exemplo, vamos inserir um evento SelectionChanged no ListBox, assim quando o usuário selecionar um item no Listbox vai abrir outra página com o link selecionado carregado no browser, para inserir o evento, selecione o ListBox, na aba properties, clique  no ícone Events e dê um duplo click no evento SelectionChanged, Figura 5.

Figura 5 – ListBox – Criando um evento SelectionChanged

Dentro do evento SelectionChanged do ListBox,  primeiro vamos obter o item selecionado no ListBox através da propriedade SelectedItem, depois através do recurso NavigationService.Navigate, vamos navegar até a outra página, passando como parâmetro a url que será carregado no Browser, Listagem 3. Adicione uma página em seu projeto com o nome de PhonePageBrowser, adicione um elemento WebBrowser e o método onNavigatedTo, esse método será responsável por obter a url e carregar o browser com o link passado, Listagem 4.

Listagem 3. XAML da aplicação

Listagem 4. XAML da aplicação

Conclusão

O Expression Blend é um poderoso aliado para a criação de aplicativos para o Windows Phone 7 com Silverlight,  vimos de forma superficial como criar uma aplicação na ferramenta, além de conhecer um pouco sobre os layout controls, sample data e navegação de páginas.

In this post we’ll see how to listen to the flash.events.Event.CLOSING event and prevent the window closing until the user’s interaction. That’s useful once you have some unsaved work in your application, so you can ask the user if he really wants to close the window before doing it.

Check out the code after the jump.

<?xml version="1.0" encoding="utf-8"?>
<s:WindowedApplication
    xmlns:fx="http://ns.adobe.com/mxml/2009"
    xmlns:s="library://ns.adobe.com/flex/spark"
    xmlns:mx="library://ns.adobe.com/flex/mx"
    closing="closingHandler(event)">
    <fx:Script>
        [CDATA[
            import mx.controls.Alert;
            import mx.events.CloseEvent;
            protected function closingHandler(event:Event):void
            {
                event.preventDefault();
                Alert.show(
                    "Do you really wanna close this window?",
                    "Warning",
                    Alert.YES|Alert.NO,null,
                    alertCloseHandler
                );
            }
            private function alertCloseHandler(event:CloseEvent):void
            {
                if(event.detail == Alert.YES)
                    nativeWindow.close();
            }
        ]]>
    fx:Script>
s:WindowedApplication>

Hope you enjoy it. See ya!

Today the Flex tip will talk about the usage of the local SharedObject object and how to implement it to store simple data objects.
When you create a SharedObject obejct the Flash Player also creates an empty *.sol file that stores the SharedObject data limited up to 100 KB per domain. If you try to saving bigger data the user must to authorize this process through a Local Storage dialog box. The supported types are: Number, String, Boolean, XML, Date, Array and Objects. You can also store typed ActionScript instances by callling the flash.net.registerClassAlias() function in order to preserve the class type of an object when the object is encoded in AMF.

Use the SharedObject.getLocal() method for create a SharedObject object:

SharedObject.getLocal("chooseSomeName"): SharedObject

For instance:

var sharedObject:SharedObject;
sharedObject = SharedObject.getLocal("MyTextInformation");

You can also create multiple SharedObjects for the same Flex application:

sharedObject1 = SharedObject.getLocal("UserInformation");
sharedObject2 = SharedObject.getLocal("TravelInformation");
sharedObject3 = SharedObject.getLocal("AgreementInformation");

The code above will create 3 files in the Flex folder:

UserInformation.sol
TravelInformation.sol
AgreementInformation.sol

In order to store these information into a SharedObject you must use the property data:

sharedObject.data.information = "the information goes here";

The method flush() causes Flash Player to write the information in the respective data file. In case you don’t call it directly, the data will be persisted once you close the browser. Therefore, it’s a good practice to call it.

sharedObject.flush();

The clear() method clears the file and removes it from the local disk.

sharedObject.clear();

Check the complete example out:

<?xml version="1.0" encoding="utf-8"?>
<s:Application
	xmlns:fx="http://ns.adobe.com/mxml/2009"
    xmlns:s="library://ns.adobe.com/flex/spark"
	xmlns:mx="library://ns.adobe.com/flex/mx"
	creationComplete="creationCompleteHandler(event)">
?
<fx:Script>
	[CDATA[
	import mx.events.FlexEvent;
?
	private var sharedObject:SharedObject;
?
	protected function creationCompleteHandler(event:FlexEvent):void
	{
		sharedObject = SharedObject.getLocal("MyTextInformation");
		if(sharedObject.size > 0)
		{
			information.text = sharedObject.data.information;
			currentDate.text = "Eu gravei essa data no objeto: " +
				sharedObject.data.currentDate;
		}
	}
?
	protected function saveClickHandler(event:MouseEvent):void
	{
		sharedObject.data.information = information.text;
		sharedObject.data.currentDate = new Date();
		sharedObject.flush();
	}
?
?
	protected function clearClickHandler(event:MouseEvent):void
	{
		sharedObject.clear();
	}
?
	]]>
fx:Script>
?
<s:layout>
	<s:VerticalLayout
		verticalAlign="middle"
		horizontalAlign="center"/>
s:layout>
?
<s:Label id="currentDate" />
<s:TextArea id="information" />
<s:HGroup>
	<s:Button label="Salvar informação"
			  click="saveClickHandler(event)" />
	<s:Button label="Apagar informação"
			  click="clearClickHandler(event)" />
s:HGroup>
?
s:Application>

References:
http://livedocs.adobe.com/flex/3/html/help.html?content=lsos_5.html

Hope you enjoy it!

Olá,

Depois de seculos sem aparecer resolvi fazer um post para divulgar um pequeno projeto que disponibilizei no github.

Trata se de uma pequena lib que implementa o Pattern Observer bem conhecido no flex através dos events.

O link para o projeto no github é : https://github.com/FabioBatSilva/events O php 5.3 é requisito para o funcionamento

La existe um pequeno wiki sobre o projeto com as funcionalidades básicas.
Desde já peço desculpa pelo inglês…rsrs

Depois de realizar o download dos arquivos
podemos utilizar a lib carregando atravez de algum autoloader como Zend_AutoLoad ou carregando manualmente:

set_include_path('/my/library' . PATH_SEPARATOR . get_include_path());
require_once 'Events/Event.php';
use EventsEvent;

Disparando Eventos :

Para disparar eventos a partir da sua classe vc terá que estender EventDispatcher e utilizar o método dispatchEvent($event)

* Esse metodo tem como parâmetro um objeto do tipo Event que sera disparado

use EventsEvent, EventsEventDispatcher;
?
class MyObject extends EventDispatcher
{
    private $name;
?
    public function setName($name)
    {
        $this->dispatchEvent(new Event(Event::CHANGE));
        $this->name = $name;
    }
?
}

Escutando Eventos :

Para escutar os evento vc deve utilizar o método addEventListener($type,$listener) do objeto que estende a classe EventDispatcher.

* O primeiro parâmetro é uma string que identifica o tipo do evento
* O segundo parâmetro a Closure/Function que será chamada quando o evento disparar

use MyObject;
$object = new MyObject();
?
$object->addEventListener(Event::CHANGE, function($event){
    echo 'My Object Has Changed';
});
?
$object->setName('New Name');

Então quando o nome é alterado o evento do tipo Event::CHANGE é disparado e todos que estiverem ouvindo por esse tipo de evento serão chamados.

Customizando Eventos :
Vc pode criar eventos personalizados, Eles poder servir para adicionar funcionalidades ao evento ou transportar dados.

use EventsEvent;
?
class MyEvent extends Event
{
    const CHANGE_NAME = 'changeName';
?
    public $oldName;
    public $newName;
?
    public function __construct($type, $oldName = null, $newName = null)
    {
        parent::__construct($type);
        $this->oldName  = $oldName;
        $this->newName  = $newName;
    }
}

Então para dispara o evento:

public function setName($name)
{
    $event = new MyEvent(MyEvent::CHANGE_NAME, $this->name, $name);
    $this->dispatchEvent($event);
    $this->name = $name;
}

E capturar os dados na função que esta ouvindo o evento:

$object->addEventListener(Event::CHANGE, function($event){
    echo "My Object Has Changed";
    echo "OLD : " + $event->oldName;
    echo "NEW : " + $event->newName;
});

É bem simples porem pode ser útil.

Abraço e até a próxima