Adobe AIR 101/ AIR 1.0/ AIR 1.1/ AIR 2.0/ AIR 2.7/ AIR 3.0/ AIR Mobile/ Flash Player

Adobe AIR perde o foco para criar Apps para dispositivos móveis

air_2_lg.jpg.adimg.mw.138

A Adobe hoje atualizou o Flash Player e Adobe AIR Whitepapers, que é um documento público mostrando as intenções da empresa desde sua mudança de foco nos últimos 2 anos.

Hoje ela acredita que suas plataformas Flash Player/ Adobe AIR continuaram fortes na arquitetura atual e abandorá todos os esforços na criação da próxima versão do Actionscript Next e Flash Player Next, que possivelmente seriam o Actionscript 4.0 e o Flash Player 12.

Ela voltará seu foco em novas VM como o V8 por exemplo do Google Chrome ou o Webkit amplamente utilizado por vários fabricantes de navegadores.
Com essas novas atualizações dos documentos, houve Buzz e ainda vai ter, veja alguns destaques de pessoas importantes dentro da empresa, e suas visões em relação à plataforma.

Já que a regra vale a máxima, Uma imagem vale mais do que mil palavras, quanto mais uma declaração como essa.

adobe_airmobile

 

Sim, nós não estamos promovendo o AIR para criação de apps para smartphones. Eu concordo que o AIR é ótimo com o Starling e o Feathers, já que você tem uma velocidade quase nativa.

 

Essa foi uma das declarações feita por alguns dos evangelistas da Adobe, em especial o Lee no Google Plus e está disponível para quem quiser ler, que hoje lidera a parte de evangelismo para Jogos.

Não é polêmica a declaração, só reafirma que o compromisso da Adobe não é só manter o foco na plataforma Flash/AIR em sí, mas dar ênfase à outra parcela de desenvolvedores que adotam o padrão aberto.

Na mesma discussão Mike Chambers reforça que o foco da Adobe para plataforma Flash é Jogos.

adobe_airmobile2

 

 

Não é que você precisa ficar desesperado por que o suporte ao Adobe AIR vai sumir do mapa e você não vai mais conseguir criar Apps usando o Adobe AIR, só para você saber quando e como usar o AIR em suas Apps, mesmo usando ele embedado na sua App.
Essa ficará para história de como destruir um eco-sistema enorme de desenvolvedores para concorrentes.

AIR 3.0/ AS 2.0/ AS 3.0/ Flash/ Flex

Lançado o SWF Investigator

magnify
A Adobe mesmo timidamente, acaba de lança no site do Labs uma ferramenta feita em Adobe AIR que o nome por sí ja entrega o que ela se propõe. Vasculhar SWF feito por desenvolvedores.

O aplicativo funciona para Mac e Windows, e vasculha desde código fonte feito em as2 e as3 assim como informações do LSO(Local sharedObject), busca por falhas e vunerabilidades no arquivo.

Para o aplicativo ser construído, eles usaram o native process, native instalation e native extensions, Ah! sem contar que o aplicativo é gratuito e open-source.

Vale a pena o Download.

Adobe AIR 101/ AIR 2.7/ AIR 3.0

Adobe AIR 101 – Como posicionar a tela do meu App no sistema operacional?

Hoje inicio uma série de posts sobre Adobe AIR, eu venho prometendo isso faz séculos, mesmo depois de ter colocado dois cursos de Adobe AIR on-line, sempre faltava aquele tempinho extra.
Nada melhor como uma ótima sexta-feira ensolarada de Sampa para começar essa série. O que é 101 séries?
Basicamente são 101 receitas de como você faz isso ou aquilo, seja em qualquer tecnologia.

O post inaugural da série seria, como posicionar a janela do meu App no sistema operacional?

É muito simples a solução. Como explicar essa facilidade? Quando você cria uma nova App no Flash Builder para a plataforma AIR, você geralmente usa o componente WindowedApplication, o WindowedApplication é a Raiz do App, você pode até trocar mais basicamente cada nova Janela Window ou Windowed que você adiciona no AIR, ele acaba indo para o systemManager, onde você pode administrar facilmente.

Cada classe Window fica armazenda no momento em que ela é criada, sendo assim o systemManager recebe elas e o NativeApplication, onde SystemManager é gerenciado pelo run-time AIR, ai é só fazer a continha básica da herança que você chegará ao resultado.

<?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"
					   width="555" height="381">
	<fx:Declarations>
		<!-- Place non-visual elements (e.g., services, value objects) here -->
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			import spark.components.Window;
 
 
 
 
			protected function changeWindowPosition(event:MouseEvent):void
			{
				if(_x.text != '' && _y.text != ''){
					nativeApplication.activeWindow.x = Number(_x.text);
					nativeApplication.activeWindow.y = Number(_y.text);
				}
			}
 
		]]>
	</fx:Script>
	<s:Button x="62" y="134" width="137" height="31" label="Mover"
			  click="changeWindowPosition(event)"/>
	<s:Form x="32" y="15">
		<s:FormItem label="x">
			<s:TextInput id="_x"/>
		</s:FormItem>
		<s:FormItem label="y">
			<s:TextInput id="_y"/>
		</s:FormItem>
	</s:Form>
</s:WindowedApplication>

Veja o código acima, como eu sei que a Janela Atual é o Próprio App, então eu não preciso instanciar ela, já que ela está visível, basta eu usar a propriedade nativeApplication e janela ativa (activeWindow) e eu consigo chegar onde eu quero para move-la de posição.

Outro exemplo bem legal que se pode fazer é o uso de efeitos, veja o mesmo código abaixo, só que agora com efeitos.

<?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"
					   width="555" height="381" xmlns:interfaces="com.riacycle.interfaces.*">
	<fx:Declarations>
	<interfaces:JanelaInterpolator id="interpola"/>
 
		<s:Sequence id="mover" target="{this}" duration="1000">
				<s:Fade duration="300"/>
				<s:Animate>
					<s:SimpleMotionPath property="tamanho" valueTo="{rect}" interpolator="{interpola}"/>
				</s:Animate>
		</s:Sequence>
 
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			private var rect:Rectangle = new Rectangle();
 
			public function get tamanho():Rectangle
			{
				return nativeWindow.bounds;
			}
			public function set tamanho(value:Rectangle):void
			{
				nativeWindow.bounds = value;
			}
			protected function changeWindowPosition(event:MouseEvent):void
			{
 
				rect.width = nativeWindow.width;
				rect.height = nativeWindow.height;
				rect.x = Number(_x.text);
				rect.y = Number(_y.text);
				mover.play();
			}
 
		]]>
	</fx:Script>
	<s:Button x="62" y="134" width="137" height="31" label="Mover"
			  click="changeWindowPosition(event)"/>
	<s:Form x="32" y="15">
		<s:FormItem label="x">
			<s:TextInput id="_x"/>
		</s:FormItem>
		<s:FormItem label="y">
			<s:TextInput id="_y"/>
		</s:FormItem>
	</s:Form>
</s:WindowedApplication>

Explicando o código:

Veja bem, quando você usa efeitos na própria janela onde você está chamando a ação, basicamente ela vai dar estouro de pilha e não funciona, justamente por que o intervalo de tempo entre a chamada e a execução acaba sendo no mesmo momento, nem que você tenha que chamar por callLater, o que na prática nunca vai funcionar. Foi ai que acabei criando o interpolador para facilitar, a execução do efeito, pegando valores anteriores do nativeWindow e aplicando os novos valores do Rect que o efeito irá aplicar.

Aqui está o código do Interpolador.

package com.riacycle.interfaces
{
	import flash.geom.Rectangle;
 
	import spark.effects.interpolation.IInterpolator;
 
	public class JanelaInterpolator implements IInterpolator
	{
		public function JanelaInterpolator()
		{
		}
 
		/**
		 *
		 * Funciona assim:
		 *
		 * Você começa com o valor x = 200 e y= 200;
		 * E soma a fração em Delta que sofre mudanças repetidas entre o valor final e o valor inicial.
		 *
		 * Basicamente se um objeto começa na posição x=200 e y=200;
		 * E você quer mudar para x=300 e y= 300;
		 *
		 * Você faz a interpolação do efeito somando o valor inicial + fração (valor Final - valor Inicial)
		 *
		 * Isso dá um incremento a posição inicial do objeto.
		 *
		 * A fração é a velocidade com que essas mudanças ocorrem, você pode incrementar elas ou não.
		 * */
		public function interpolate(fraction:Number, startValue:Object, endValue:Object):Object
		{
			return new Rectangle(startValue.x + fraction * (endValue.x - startValue.x),
				startValue.y + fraction * (endValue.y - startValue.y),
				startValue.width + fraction * (endValue.width - startValue.width),
				startValue.height + fraction * (endValue.height - startValue.height));
		}
 
		public function increment(baseValue:Object, incrementValue:Object):Object
		{
			return new Rectangle(baseValue.x + incrementValue.x,baseValue.y + incrementValue.y,
				baseValue.width + incrementValue.width,baseValue.height + incrementValue.height);
		}
 
		public function decrement(baseValue:Object, decrementValue:Object):Object
		{
			return new Rectangle(baseValue.x - decrementValue.x,
				baseValue.y - decrementValue.y,
				baseValue.width - decrementValue.width,
				baseValue.height - decrementValue.height);
		}
	}
}

Outro problema é que você tem que criar um retangulo para re-posicionar a tela que você está fazendo as mudanças, uma vez que você cria essas proporções a própria nativeWindow ou nativeApplication sempre que muda de posição é alterado os valores, então o mais correto é pegar os bounds, área da janela atual e corrigir isso através de uma propriedade própria sua, retardando o processo.
Já que as mudanças sofridas pelo nativeWindow são imediatas, devido não ter o immediatePropagation(); Impedindo que elas ocorram, você tem que recorrer ao fato do Rect para se salvar desse pequeno problema.

Esse efeito acaba valendo também para modificar o tamanho da janela em si, assim como redimencionar o tamanho de acordo com o conteúdo.

AIR 3.0/ AIR Mobile/ Android/ Flash Player 11

Flash Player 11 e Adobe AIR 3.0 lançados oficialmente

Está acontecendo entre os dias 01 e 05 de Outubro o Adobe MAX 2011. Como todo ano da conferência a Adobe libera novidades para sua familia enorme de desenvolvedores e designers; E uma dessas grandes novidades foram as mais esperadas no mundo dos desenvolvedores o Adobe AIR 3.0 e o Flash Player 11.


Para você ter uma idéia, o Flash Player 11, dá suporte nativo a 64 bits, finalmente os navegadores vão parar de travar e você não tem que ficar usando alguma gambiarra.

Dentre várias novidades que eu já destaquei aqui . O Flash Player 11 sem dúvidas está mais que redondo, eu arrisco falar que era para ser esse o Flash Player 9, lançado a 5 anos atrás. Em fim, nada acontece como agente espera.

Se você tem o Flash Player 11 beta como eu tenho, desinstale totalmente e instale o novo, a coisa muda da água para o vinho, mesmo sendo beta, alguma coisa eles fizeram de voodoo do beta para essa versão final que ficou bem mais rápida.

Veja aqui a lista completa de novidades do Flash Player 11 e surpreenda-se.

Ah ! E claro, atualize agora o seu, clique aqui.

Outro produto run-time e cada vez mais se tornando carro chefe da Adobe principalmente no mundo móvel é o Adobe AIR 3.0.

Sensacional é a novidade do Native Extensions, eles acertaram em cheio nessa novidade que basicamente é, você pode criar N possibilidades para a API do Flash/Flex/AS3, sem a necessidade de esperar a Adobe criar APIs para tal, isso elimina ela de uma grande responsabilidade de colocar essas API prontas, e encoraja a comunidade de desenvolvedores de criar suas próprias soluções, isso me lembra muito as .dll do Windows no antigo visual basic.

Comparações a parte, essa foi a melhor release ou seja pulo do gato no Adobe AIR 3.0. Estou pensando nas incríveis capacidades que as aplicações móveis terão em relação ao SDK nativo que cada plataforma tem.

Veja aqui a lista completa das novidades do Adobe AIR 3.0. Tem inúmeras, como já relatei aqui.

Atualize seu Adobe AIR 3.0 no seu Android, PC agora, veja como aqui.