Dopo oltre un decennio di attività da free lance per lo sviluppo e la consulenza su Flash, Flash Media Server e, successivamente, Flex (fin dalla versione 1) e Flash Lite, ho formato e dirigo un team di professionisti che hanno una profonda conoscenza di queste tecnologie ed un solido background in Java, EJB3, Struts, Hibernate, POJO e Spring in ambiente Java Enterprise (J2EE).
Oltre a frequenti attività di supporto ad Adobe in importanti progetti nell’area EMEA (EuropeMiddleEastAfrica), questo team di consulenza e sviluppo è stato ingaggiato più volte da prestigiose aziende worldwide per consulenza in materia di analisi, sviluppo e ottimizzazione di applicazioni in cui gli aspetti gestionali e di sicurezza tipici del mondo enterprise integrano saggiamente l’attenzione alla user experience che è il fulcro dell’approccio RIA (Rich Internet Applications).

Se hai bisogno di assistenza per un'applicazione interna o vuoi rendere un'applicazione eistente più ricca e accattivante, o se hai un'idea che vuoi realizzare utilizzando le più moderne, efficaci ed affidabili tecnologie disponibili sul mercato quello che stai cercando è il mio team! Forniamo consulenza e assistenza in ogni parte del mondo, on site e off site, both on a Time&Material and on a TurnKey basis.

Per contattarmi in merito ad attività di consulenza, scrivi una email a consulting[ AT ]comtaste.com

Past week the Flex Doc Team at Adobe released the documentation for LiveCycle Data Services Es 2.5. The documentation was realeased in livedocs format so you were able to read on the web.

Randy Nielsen, the Learning Resources Manager at Adobe Systems Incorporated, send me an email to point me out that the LiveCycle Data Services Developer’s Guide has been released in PDF format.
So we're now ready to download and print it !

This is the entire LiveCycle Data Services documentation :

* Getting started - http://livedocs.adobe.com/livecycle/es/sdkHelp/programmer/lcds/getstarted_1.html
* LiveCycle Data Services Developer’s Guide - [ LiveDocs ] | [ PDF ]
* LiveCycle Remoting - http://livedocs.adobe.com/livecycle/es/sdkHelp/programmer/sdkHelp/Invoking_LiveCycle/invokingLCRemoting.2.1.html
* LiveCycle ES ActionScript Language Reference (includes Flash Player, Flex SDK 2.0.1 hotfix 2, Data Services, and LiveCycle Form Guide classes) - http://livedocs.adobe.com/livecycle/es/sdkHelp/common/langref/index.html
* LiveCycle Data Services JavaDoc - http://livedocs.adobe.com/livecycle/es/sdkHelp/programmer/lcdsjavadoc

Flex Doc Team rocks !
They made an excellent job for the Flex and LiveCycle Data Services Es 2.5 documentation.
Thanks guys !

Today is the second day of AdobeLiveConference here in Italy.
I'm here with Enrique (and some enormous mosquitos) in the business room of the AdobeLive and we're about to start our presentation.

Enrique will present Adobe AIR (formerly Apollo) and talk about Flex 3 and new features.

After his presentantion I'll show the integration of the Adobe CS3 with Flex and Flex Builder.
It's incredible how many things designers and creative are now able to do to help Flex developersin creating the user interface of Flex applications.
Using Photoshop CS3, Fireworks CS, Illustrator CS3 and Flash CS3 , of course, they can export graphic symbols, layouts and components for the Flex enviroment.

With Fireworks CS3 you can now use the Exoprt as MXML features to convert a PNG layouts into MXML code. You can do this using the new Flex Component Common Library (you can also create your own Flex components using an image and a javascript JSF file).
The MXML code generated from Fireworks is ready to be edited and customized by the developer in Flex Builder.

With Illustrator CS3 you can create vector based symbols and export them as SWF files, ready to be used and imported in Flex. For example you can export your vector symbols and then use them for change the style of a button flex component usign :

overSkin: Embed(source='styles.swf', symbol='mysymbol');
upSkin: Embed(source='styles.swf', symbol='mysymbol');
downSkin: Embed(source='styles.swf', symbol='mysymbol');

Then in Flash CS3 you can do whatever you want with the Flash CS3 Component Kit for Flex. You can interact in Flex with Flash contents, call public methods, refer to each single object.

If you're in Milan come to see the sessions !
They're great !

We're working on some projects in Flex where the use of the keyboard to navigate through the application is a key aspect.
They're both Flex 2 form based application

Our goals were :
- at the start up of the application give the focus to the first form field
- pressing the tab key cycling the focus through all the form fields

Although it seams like very simple, the focus in Flex 2 is not so easy.
We had strange behaviour that mostly depend on how the Internet Explorer uses the ActiveX contents :
- although when the application has been loaded the foucs was on the first field, pressing the tab key once, the focus goes outside the Flash Player applet to the browser controls

To solve the problem of the fucus lost by the Flash Player you can use this small workaround :

keyFocusChange="event.preventDefault();focusManager.getNextFocusManagerComponent(event.shiftKey).setFocus()"

The keyFocusChange is on the Application tag.

In order to make the focus in Flex 2 works for Internet Explorer, it's not enough to set it up using Javascript when the page loads.
Internet Explorer does not give you the ability to an ActiveX content to get the focus.
So for example in a Flex 2 application that has 3 text inputs when the last one has the focus and you click on the tab, the focus quits from the Flash Player 9 ActiveX and goes to the HTML page content.

That's a bad behavior for your application.

To overcome this problem we have to intercept the key pressed by the user and disable the default action of the browser to prevent the browser handling of the key.

When you develop enterprise flex application the Quality Control phase (QC) is a fundamental aspect of each software development activity.
Flex and the LiveCycle Data Services ES include The Flex Automation Framework.

The Flex Automation Package provides developers with the ability to create Flex applications
that use the Automation API. You can use this API to create automation agents or to ensure
that your applications are ready for testing. In addition, the Flex Automation Package includes
support for Mercury QuickTest Professional (QTP) automation tool.

You can create applications and components that can be tested with automated testing tools
such as Mercury QuickTest Professional (QTP). This topic includes information intended for
Flex developers who write applications that are then tested by Quality Control (QC)
professionals who use these testing tools.

Continue reading the full Creating Flex Applications for Testing document.

On the Adobe MAX 2007 blog has been published the pre-conference training day, a full-day hands-on training sessions. These are the tracks dedicated to Flex 3, Adobe AIR and LiveCycle Data Services :

Flex 3: Integrating with ColdFusion
This session provides ColdFusion developers with hands-on, practical experience connecting their Flex 3 client applications to remote, dynamic data provided by ColdFusion and LiveCycle Data Services.

Flex 3: Integration with Java
This session provides experienced application developers with hands-on, practical experience connecting their Flex front ends to remote, dynamic data using LiveCycle Data Services.

Flex 3: Developing Rich Client Applications
Get hands-on, practical experience using Flex.

Adobe Integrated Runtime (AIR): Bringing Rich Internet Applications to the Desktop
This full-day course will include everything you need to get started building applications with Adobe AIR.

LiveCycle Data Services overview

LiveCycle Data Services, formerly known as Flex Data Services, is a powerful Adobe product that allows seamless interaction between a Flex client and any Java EE based server or most J2EE servers.
These services allow Java object or services to be called directly from the Flex client, in a transparent way: all the developer has to do, in the Flex code, is call remote services just like they were Flex functions or methods. All the problems related to marshalling / unmarshalling, mapping Flex and Java classes and types are solved internally by LiveCycle Data Services. For all of this to work, LiveCycle Data Services only requires some configuration to be provided, that will define the required behavior.
Using LiveCycle Data Services is, without doubt, one of the best approaches to consider in developing enterprise RIA applications, as it takes care, in an efficient and scalable way, of all the information exchanged by the Flex client and the Java server.

An eye on the server side

Connecting the client to the server being taken cared of, the development can just focus on creating a client and a server layer that handles any required business logic and persistence. LiveCycle Data Services is a Java EE web application, that has to be deployed into a Java EE container. From there it can access whatever server side required functionality and provide it to the Flex client. This kind of deploy ensures compatibility with existing Java EE application as well as with newly created applications. Connecting a LiveCycle application with an existing Java EE or J2EE application requires a little work, but we’ll cover it up in a future post.
The Java EE applications covered in the following blog posts will be the ones that use either Hibernate as a persistence manager or EJB3 in Java enterprise applications. We will see how to access Hibernate or EJB3 from LiveCycle Data Services, how to keep the data services separated from the Java business logic, using clean, modular and distinct components.

The world behind LiveCycle Data Service and Java

LiveCycle Data Services offers many possibilities, like accessing remote Java objects, binding client to server data sources, using publisher/subscribe messaging to communicate with the server, with or without JMS. Aside all these it’s also possible to configure a LiveCycle Data Services EE application to allow a controlled Flex client access to areas like Hibernate’s named queries, JNDI lookup or web server custom login.
LiveCycle Data Services offers numerous possibilities and can be configured and understood to get the outmost out of this potential.

Web resources
LiveCycle Data Services can be found here, http://www.adobe.com/products/livecycle/dataservices/, Hibernate http://www.hibernate.org/ contains all required resources and libraries. A commonly used Java EE web servers is Tomcat http://tomcat.apache.org/, while JBoss http://labs.jboss.com/ is an enterprise application container.

Adobe LiveCycle Data Services ES, formerly called Flex Data Services (FDS), provides data services such as remoting, data push, publish and subscribe for Flex applications. With LCDS you can integrate flex with J2EE infrastructures and a previuos post on our blog shows an example: LiveCycle Data Services and Hibernate integration in Flex RIA applications.
There are a lot of open source projects around flex, flash and AMF, and, on java side, GraniteDS is one of the most promising.
It's developed under the LGPL and proposes itself as an alternative to Adobe® LiveCycle® (Flex™ 2) Data Services for J2EE application servers.
GDS is still in an early development phase, with a 0.3 version released on july 30, while, at the time of writing, the 0.4 one is in a release candidate state; despite this, it's rather stable and you can safely test it in non critical production environment as its home page suggests.
Here they are the features already implemented and the planned ones; this list is continuously updated

• Full AMF3 support. See GDS AMF3 documentation.


• EJB3 services with transparent externalization mechanism and lazy initialized ActionScript 3 beans (Entity Beans / Hibernate). See EJB3 Services and Externalizers and Lazy Initialization.
• EJB3 Entity Bean to ActionScript 3 classes code generator. See AS3 Generation.


• Spring services. See documentation on Spring Services.


• POJO services (remote calls to simple Java classes that expose public methods). See Pojo Services.
• (planned) Data push. A Comet-like implementation with AMF3 data polling over HTTP (event/listener based architecture).


• (planned) Entity repository: a client side entity repository that ensures uniqueness (only one instance of each entity is present in the flash VM), weakness (only currently bound objects are kept in memory), and that acts as a services frontend (all server calls/events are managed by this central component). This will be loosely inspired by Cairngorm.


• (planned) Seam integration: a reliable GDS/Seam integration with full scopes (at least conversation) support.
• (planned) A set of Flex components suitable for complex data structures.

A key feature, implemented in version 0.3, is the support for setCredentials, setRemoteCredentials and logout methods of RemoteObject, more information in the release notes: http://www.graniteds.org/confluence/display/DOC03/Documentation+-+0.3

They provides various demos which you can you use importing them as new eclipse projects:

• graniteds-ejb3-0.3.0.zip: a basic sample with Granite DS and EJB3 working together


• graniteds-spring-0.3.0.zip: a basic sample with Granite DS and Spring working together


• graniteds-pojo-0.3.0.zip: a basic sample with Pojo and Granite DS

Moreover a live demo that shows Granite DS in action is available.

If you are interested in testing your LCDS application with Granite Data Services you have to make some changes according to the good documentation ready to help you; however you should check if all the features you need are implemented.
Granite DS is a promising project and the development is going on quite fast, but it still misses some important functionalities like messaging services and data push (planned feature) so by now LCDS is a must in a stable production enviroment, but i can suggest to keep an eye on GDS for the future.

In a Flex application that uses LiveCycle Data Services or the previous Flex Data Services to manage data from a remote server there is the requirement that Flex domain model classes have to match Java domain model, in structure, properties and types. Usually it means that for each Java class that is supposed to be configured as a remote alias one should write down an ActionScript class with the same properties, just as described in the Adobe livedocs at Livedocs
The documentation provides a mapping for ActionScript data types and Java data types and specifies that Java classes are dealt with through the Java Beans specification, that can be downloaded here: Javabeans

The Java class is serialized and all of its public properties and the ones with getter and setter methods are serialized. All other properties are not, including the ones without a getter. There is one thing related to the Java beans that worths a bit of attention, and it is bean attribute names that start with a lower case character followed by a upper case character: their getter and setter methods will have get/set followed by at least two upper case characters, for example "aFoo" will have "getAFoo" and "setAFoo". When the Java introspection mechanism, described in the above specification, finds these kind of properties, it will infer that the property is called "AFoo". That implies that inside the ActionScript class that matches the Java bean the property has to be called "AFoo", otherwise it will not be recognized. This usually translates on the flash log in a "ReferenceError: Error #1056: Cannot create property AFoo on [...]".

Consider the case where all of the properties of a class are declared in Java with a lower case followed by an upper case, one could easily convert into an ActionScript class that follows the same naming convention and, at runtime, there will be an empty object, with the right type but no contents; the ReferenceErrors in the flashlog will point out the problem and the solution, in this case, is to call ActionScript properties starting with two upper case characters: "AFoo".

Iin an enterprise application there can be many Java bean classes to be converted to ActionScript counterparts, a simpler way of solving this and possibly other problems related to Java to ActionScript conversion would be the use of an automatic tool. At the time of writing this blog post I personally did not find a tool that performs the conversion, a tool that can be easily integrated into an IDE, like Eclipse, or used as an Ant task, thus I'm considering writing one myself. The backend of this tool would use java.beans.Introspector to get the java.beans.PropertyDescriptor for each property of the bean, map the Java types to the ActionScript ones and generate the required imports. I'll keep the blog updated with progress on the tool, as well as interesting parts of the source code.

Adobe has just announced the BlazeDS beta release. On Adobe Labs today we can read that "BlazeDS is the server-based Java remoting and web messaging technology that enables developers to easily connect to back-end distributed data and push data in real-time to Adobe® Flex™ and Adobe AIR™ applications for more responsive rich Internet application (RIA) experiences."

As a matter of fact, BlazeDS is an open source part of LiveCycle Data Services, while the complete Live Cycle suite will still be closed source and subject to Adobe’s Licensing policy.

The source code will be available for download in early 2008 (http://labs.adobe.com/technologies/blazeds/).

Adobe has also published AMF binary data protocol specification, on which the BlazeDS remoting implementation is based.

BlazeDS introduces the concept of HTTP streaming, that enables clients to maintain persistent connections with backend servers. HTTP streaming will practically allow the same data push functionality that is available with the LiveCycle Data Services, with the difference that the streaming will not use the RTMP messaging channel.

Among the news, Adobe will offer Adobe LiveCycle Data Services, Community Edition, a subscription offering that includes certified builds of BlazeDS, access to Adobe enterprise support resources and additional benefits, such as product warranty and infringement indemnity, as well as additional developer support.

After the release of the Flex SDK open source, Adobe gives further signals of willingness to pursue the construction of a stronger and wider developers' community.

I want to point out for the readers of this blog (mainly Java, Flex and Livecycle developers) an article I published on my personal blog :
Passing connection-level credentials to the JMSAdapter of BlazeDS
One of the limit if the Messaging Services of Livecycle Data Services is the inability to define a username and password in the configuration file to pass them to the JMS.
I discovered that in BlazeDS there is a new JMSAdapter that allows you to set the connection-level credentials passing the username and password.
The new connection-credentials XML node sets the the username and password used while creating the JMS connection.As the documentation said, use only if JMS connection level authentication is being used :

...

Topic
javax.jms.TextMessage
jms/flex/TopicConnectionFactory

jms/topic/flex/simpletopic

NON_PERSISTENT
DEFAULT_PRIORITY
"true"
AUTO_ACKNOWLEDGE

1

For many developers this new features supported by the JMSAdapter could be very appreciated and could solve problems in many different scenarios where the authentication is required in JMS.

Read the full Passing connection-level credentials to the JMSAdapter of BlazeDS article.