After I saw some tweets about issues related to accessing the Wi-Fi network from an AIR application running on Android I thought it is worth writing a post about this topic.

If you installed an Android application on your phone you know that during this process you are presented with a screen stating what permissions the application you are about to install will use: network communication, contact data, location, storage, and so on.

I think this is a good thing especially when dealing with applications from “not so trusted” sources. You have a last chance to decide if you are willing to install that app or not. Thus it is only natural Android apps build with Adobe AIR to follow the same rules. One more thing on security/permissions: I think it is a best practice, as a developer, to request the minimum permissions required for your application.

The way you setup these permissions is quite simple: you add an <android> node to your application descriptor file having the root the <application> node (the application descriptor file is the XML file you already use for setting the different configuration options for your AIR application – application name, enabling the update framework, initial size and position, and so on). Here is an example:

<android>
    <manifestAdditions>
        <manifest>
            <attribute name="android:installLocation" value="auto"/>
            <data>
            <![CDATA[
                <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
                <uses-permission android:name="android.permission.INTERNET"/>
                <uses-permission android:name="android.permission.WAKE_LOCK"/>
                <uses-permission android:name="android.permission.DISABLE_KEYGUARD"/>
                <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
                <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
            ]]>
            </data>
        </manifest>
    </manifestAdditions>
</android>

In this example I added an additional setting in the form of <attribute name=”android:installLocation” value=”atuot”/> in order to allow the user to install the application either on the internal memory or on the SD memory card. The same way you can add additional permissions supported by the Android OS.

Now, next time when you have problems accessing resources from your AIR app on Android, you should know what is the first thing to look for.

The next version of the Flex SDK, codename Hero, is available to you for download now. If you want to check this special builds just go here and download.

What is so special about Hero? Well, the most important thing is the added support for mobile development. So far you’ll find in this builds: Spark DataGrid, Spark Image, Spark Form, OSMF 1.0 integration, Mobile Application, View & View Navigator, and ActionBar. You can read more here.

No go and start play with it already :D!

My fellow evangelist, Piotr Walczyszyn, was very busy this summer tinkering with a number of projects that involve Adobe AIR. The latest one is library that enables you to update native AIR applications. You probably know that AIR 2 introduced a cool feature that lets you call processes from your AIR application (Native Processes API) as long as you package your application as a native installer (EXE, DMG, RPM etc). Once you do this, the built-in feature for update doesn’t work anymore.

If you want to have update capabilities with AIR 2 native installers you can use Piotr’s library or you can build your own mechanism. The choice is pretty simple, isn’t it?

Here is a video in which Piotr demos the library:

You can get the library from here or read Piotr’s post.

We’ve just launched Adobe AIR Launchpad: an AIR application that can speed up your AIR development.

How does AIR Launchpad help you? Here is a list of some of the features:

• It creates the folder structure for an AIR application ready to compile with the settings you want it. For example, if you want to use auto update feature, then it will create the server side folder and files needed for this feature to work. If you’ve done AIR development you know that most the configuration options you need to set are stored inside of an XML file. Well, this application provides a user interface for setting these options. So it makes it easier to set up the icons used by the app, default width/height, or making the app transparent.
• It creates an install badge if you need one (you can provide the image you want to be used).
• It helps you to hook up listeners for events like Activation/Deactivation, Close event, Global Error.
• It generates sample code for tasks like: Drag/Drop, Local Databases, Using Windows, HTML Component, Native Process, and many more.
• It can create a ZIP file with all these folders/files so you can import this ZIP in Flash Builder and continue the working on the application using this IDE.

Here are some screenshots:

You can get this application from here.

LiveCycle Collaboration Service just got three new features that I’m pretty sure will make you very happy:

• Screen Sharing. Yes, this is exactly what the names implies. Now, you can add screen sharing to your applications. Amazingly cool isn’t it?
• Recording and Playback. You can record and download your collaborative session, and then playback this recording. You will see the data, audio, and video.
• LCCS JavaScript SDK. We added JavaScript APIs and you can code your collaborative service using JavaScript. Though you still have to embed a SWF in your HTML page.

We also changed the domain name to something more meaningful: http://collaboration.adobelivecycle.com and we have a new logo for this service :).

You can read more on the team’s blog, and my fellow evangelist, Tom Krcha, has examples on his blog. Sign up here and get the SDK, use these forums to post questions and feedback, and learn about it here.

The summer is almost over (at least in the northern hemisphere :D) which means you are in one of these two situations: either you just came back from vacation or you’re about to take one. Either way, I think you’ll find (some of) the webinars we are doing this month quite interesting. As usually, they are free; you just have to sign up and show up. A word of warning: because all four of these webinars are delivered by EMEA platform evangelist, we decided to schedule them in such a way that works for Europeans.

Here is the list:

• Building Multi-Screen / Interconnected apps for Android and desktops (Mihai Corlan) – Friday, Augst 20
• Summer Cocktail: Doctrine 2, Zend Framework, Flex, and Flash Builder (Mihai Corlan)- Tuesday, August 24
• Advanced P2P programming in Flash (Tom Krcha) – Friday, August 27
• Presentation Model pattern with Flex and Swiz Framework (Piotr Walczyszyn) – Tuesday, August 31, 2010

Enjoy!

We’ve just released a new version of Flash Player: 10.1.82.76, which includes support for H.264 video GPU decoding. This was previously available in a beta release code-named Gala. On top of this new cool feature, there were a number of bug fixes, so you definitely you should install it as soon as possible.

You can get the installers from here (including debugging versions). You can read about the security updates here.

LATER UPDATE:

I almost forgot to tell you about the new version of Adobe AIR (2.0.3). Like in the case of Flash Player, besides a number of bug fixes, we added support for GZIP compression for Windows (this was already available for Mac OS X and Linux).

You can get the runtime from here.

I finally got some time to play with Doctrine 2 and Flex. Back in May I wrote an article about working with Doctrine 1.x and Flex (you can read the article here) and my feelings were mixed. I chatted with Jonathan Wage of Doctrine about some of the shortcomings I found in Doctrine 1.x and his response was to check Doctrine 2 (still in development at the time of writing this article). Doctrine 2 is a big step forward.

In this article I describe how I rewrote the original application I created for my first article, this time using Doctrine 2, Flex 4, Zend Framework, and the Flash Builder data-centric development wizards. I’ll highlight the relevant differences between Doctrine 1 and Doctrine 2 along the way. Thus, you should find this article valuable in any one of these two cases:

• You are already working with Doctrine 1 and you’ve wondered what it would take to move to version 2
• You want to learn how to use Doctrine 2 with Flex; you know PHP and you know enough Flex not to be scared away if you see some snippets of code

Before going into the details let me say this: if you aren’t already using an ORM framework for PHP then you should. For most projects it can help you by freeing you of the tedious tasks of writing CRUD code and SQL queries. It allows you to focus on the business logic of your application. And all these advantages are multiplied when working on Rich Internet Applications because on this kind of project much of the work is done on the client and not on the server.

There are some aspects of using this ORM with RIA that could be better, but hey we don’t live in a perfect world. Most of these things, I think, are related to the fact that every time you use a server side ORM with a rich client, you leave behind the main story used for creating that framework – you use the ORM in order to feed a rich client with data and enable the client to persist the changes. Thus you need additional boiler plate code to make the whole thing work.

If you don’t know much about ORMs in general, you may want to read my first article first and before continuing.

The Big Picture

Here is a screenshot of the application I built running in the browser:

below is the database structure. The only difference between this database and the one used in the previous article is the addition of a simple primary key to the marks table.

While this is by no means a complex application, I think it’s a decent one in terms of relations between tables: I have a number of courses and countries (courses and countries tables), and each student belongs to a country (many-to-one between students and countries) and receives marks for a number of courses (marks many-to-many table for students and courses tables).

The Flex application reads all the data stored in the MySQL database and lets the user fully edit students by performing the following operations:

• Add, edit, delete students
• Change the country for a student
• Change the courses taken by a student and assign marks for a course

And here is an overview of the different parties involved in this application:

Differences between Doctrine 2 and 1.x

Before explaining how I built the app, let’s talk a little bit about the main differences between Doctrine 2 and Doctrine 1.x (as I’m writing this article Doctrine 2 is still in Beta, so things could change).

The biggest change by far is the one related to the main pattern used by the Doctrine 2 ORM. In 1.x versions it used the Active Record pattern (Ruby on Rails uses Active Record too), now you can say goodbye to Active Record and welcome Data Mapper (Hibernate uses the same pattern). What are the differences between these two patterns?

With Active Record the entities know how to persist themselves to the database; basically each entity extends some sort of a class from the ORM framework and implements methods like read(), find(), delete(), and update(). Although it is not mandatory, the entities look very much like the database structure.

With Data Mapper entities know nothing about the persistency layer and nothing about the database structure. The ORM provides the means to persist the entities and read the data into entities (from the database).

From a Rich Client perspective this translates in less work on the PHP side when preparing data for sending across the wire while using Doctrine 2. With Doctrine 1, the data model was heavy due to the Active Record pattern. Thus I had to create a plain vanilla data model used to send the data to the Flex client. In order to efficiently transform the heavy entities used by Doctrine 1 into the plain vanilla ones used for sending the data to Flex, I had to write custom functions. When data came in from the Flex client, the reverse process was needed: use the plain vanilla objects to build the Doctrine entity objects. An alternative could be to send all the data to Flex as arrays. Unfortunately, this approach doesn’t work out of the box; you have to write functions to transform the graph of objects into a graph of arrays/associative arrays.

With Doctrine 2, I don’t need this extra layer of simple value objects and I can return the data as a graph of objects or arrays with the built-in capabilities.

The second big difference is that Doctrine 2 requires PHP 5.3 or newer. Thus, if your setup requires older versions of PHP, then you have to stick with Doctrine 1.x.

Of course the ripples stirred by these two changes are quite big and I think it is safe to say that when moving from Doctrine 1.x to 2 you won’t reuse much of your previous experience with Doctrine 1.x or the code you wrote.

Having said this, I have to say that I, for one, am happy with the evolution of Doctrine, because I favor Data Mapper over Active Record.

Installing Doctrine 2 and creating the PHP project

First of all you need to get the Doctrine framework. There are four different ways (PEAR , Package Download, GitHub, or SVN). Depending on what method you use the configuration of Doctrine will differ a little bit. I used GitHub for my project, and I pulled out the code outside of Apache’s web root.

Speaking of the project, I used Eclipse PDT with Flash Builder 4 (I installed the Flash Builder plug-in on top of Eclipse PDT). The first step after getting the Doctrine framework was creating a PHP project named students-doctrine2. Next I added Flex nature to the project by right-clicking on the project name and choosing Add/Change Project Type… > Add Flex project type from the contextual menu. Make sure you select PHP for the Application Server type and you fill in the path and URL for your web root.

The next step was to create a folder inside the web root where I’ll put the PHP services, entities, and Doctrine’s configuration files: doctrine2_students. Inside of it, I created three folders named entities, proxies, and services. And finally, I created a linked resource between doctrine2_students folder and my Eclipse project (right-click on the project, choose New > Folder and then click on Advance button and navigate to the folder location). With that I was ready to write PHP and Flex code.

The next step is to create a bootstrap file (I call it bootstrap.php and place it inside of the doctrine2_students folder) that configures Doctrine 2 to be usable with my project. This means to load the framework classes, set up database access information, specify entities location and annotation method, and configure the different caches that will be used by the app. In the same bootstrap file I created an instance of the EntityManager class. This is the entry point to the Doctrine 2. If you download the project source code (see the links from the second to last section) you’ll find the bootstrap.php file inside of the doctrine2_students folder. The file looks like this:

<?php

use Doctrine\ORM\EntityManager,

    Doctrine\ORM\Configuration;

$applicationMode = 'development';

//Doctrine Git bootstrap

$lib = '/Users/mcorlan/Documents/work/_git/doctrine/doctrine2/lib/';

require $lib . 'vendor/doctrine-common/lib/Doctrine/Common/ClassLoader.php';

$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\Common', $lib . 'vendor/doctrine-common/lib');

$classLoader->register();

$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\DBAL', $lib . 'vendor/doctrine-dbal/lib');

$classLoader->register();

$classLoader = new \Doctrine\Common\ClassLoader('Doctrine\ORM', $lib);

$classLoader->register();

//additional Symphony components for Doctrine-CLI Tool, YAML Mapping driver

$classloader = new \Doctrine\Common\ClassLoader('Symfony', $lib . 'vendor/');

$classloader->register();

//load entities

$classloader = new \Doctrine\Common\ClassLoader('entities', __DIR__);

$classloader->register();

$classLoader = new \Doctrine\Common\ClassLoader('proxies', __DIR__);

$classLoader->register();

//load services

$classLoader = new \Doctrine\Common\ClassLoader(null, __DIR__ . '/services');

$classLoader->register();

if ($applicationMode == 'development') {

    $cache = new \Doctrine\Common\Cache\ArrayCache;

} else {

    $cache = new \Doctrine\Common\Cache\XcacheCache();

}

$config = new Configuration;

$config->setMetadataCacheImpl($cache);

$driverImpl = $config->newDefaultAnnotationDriver(__DIR__ . '/entities');

$config->setMetadataDriverImpl($driverImpl);

$config->setQueryCacheImpl($cache);

$config->setProxyDir(dirname(__FILE__) .'/proxies');

$config->setProxyNamespace('doctrine2_students\proxies');

if ($applicationMode == "development") {

    $config->setAutoGenerateProxyClasses(true);

} else {

    $config->setAutoGenerateProxyClasses(false);

}

//database connection config

$connectionOptions = array(

    'driver' => 'pdo_mysql',

    'dbname' => 'students',

    'user' => 'mihai',

    'password' => 'mihai'

);

$GLOBALS['em'] = EntityManager::create($connectionOptions, $config);

Creating the PHP entities

With Doctrine 2 (and any ORM that uses the Data Mapper pattern) you have to specify how an entity is persisted by the framework and what relationships it has with other entities (if any). in Doctrine 2 you can choose from four different methods: annotations, YAML, XML, and plain PHP. I initially favored the first one because all the information is stored in the entities classes as PHPDoc comments. Thus if you want to modify an entity you have only one place to look for it. However, after using this approach I think the XML approach is best because you get code-completion hints. Here is the listing for the Course entity (remember I have four tables in my database and I need four entities for my application):

<?php

namespace entities;

/** @Entity 

 * @Table(name="courses") 

 */

class Course {

    /**

     * @Id @Column(type="integer")

     * @GeneratedValue(strategy="AUTO")

     */

    private $id;

    /** 

     * @Column(type="string", length=255) 

     */

    private $name;

    public function getId() {

        return $this->id;

    }

    public function getName() {

        return $this->name;

    }

    public function setName($val) {

        $this->name = $val;

    }

}

Using annotations you specify what table is used for the entity (remember one row from that table will be wrapped in one instance of the entity). You can set different names for the properties if you want (in SQL you don’t use camelCase notation, but in PHP or ActionScript typically you use this convention).

The entities I created closely follow the structure of the database. The only difference is in how the foreign keys are represented. For example, the Student entity, which has a many-to-one relation with the Country entity, doesn’t have a property country_id of type int. Instead, I added a property called country that is of Country type. Similarly, I created a property called marks that holds an array of Mark entities – if a student attends three courses, then its marks property will hold an array of Mark objects with three instances.

Here are some notes on creating entities with Doctrine 2:

• With Doctrine 1 I used the built-in tools to create the domain model from the database structure
• Doctrine 2 has support to create the YAML out of the database schema, and then generate the entities; however I’m not sure it is good idea to do this. If you have complex schemas the generated code might not worked as you expect, and you’ll need to tweak it manually anyway
• You have to remember to set the properties as private/protected and not public, and add getters/setters. If you fail to do this, you might get nasty bugs (Doctrine will have problems injecting the code to handle relations).

Creating the PHP services

With the four entities in place, it is time to create the PHP services. These will be the services used by the Flex client to get and persist data. Basically, using the Zend Framework I’ll be able to invoke remote procedure calls on these objects from the Flex side.

Inside the doctrine2_students/services/ folder I created four PHP files: CountriesService.php, CoursesService.php, MarksService.php, and StudentsService.php.  I edited the bootstrap.php file to load the services folder along with the rest of the files. Here is the listing for the CountriesService class:

<?php

require_once(__DIR__.'/../bootstrap.php');

class CountriesService {

    public function __construct() {

        $this->entityManager = $GLOBALS['em'];

    }

    public function getCountries() {

        $q = $this->entityManager->createQuery('SELECT c FROM entities\Country c ORDER BY c.name');

        return $q->getArrayResult();

    }

}

As you might expect, the complex code is inside of StudentsService class; here’s the public API:

class StudentsService {

    //returns all the students

    public function getStudents() {

        ...

    }

    //save changes for an existent student, or insert a new one

    public function saveStudent($student) {

        ...

    }

    //deletes a student

    public function deleteStudent($student) {

        ...

    }

}

As I said before, the entry point to Doctrine 2 is its EntityManager class. You can use this class to query for persistent objects using different methods. The most powerful method is Doctrine Query Language (DQL) which resembles SQL but works on the entities you’ve defined in your domain model rather than on the underlying tables.

If, for example, you want to retrieve the country with the id equal to 1, you could use this code:

$id = 1;

$dql = 'SELECT c FROM entities\Country c WHERE id = ?1';

$query = $entityManager->createQuery($dql);

$query->setParameter(1, $id);

$countryEntity = $query->getResult();

If you want to change the name for this country, you’d write this code:

$countryEntity->setName('new name for your country');

//persist the changes to database

$entityManager->flush();

If you want to create a new country, you’d write this code:

$countryEntity = new entities\Country();

$countryEntity->setName('Mihai\'s country');

//set the entity to be managed by Doctrine

$entityManager->persist($countryEntity);

//persist the changes to database

$entityManager->flush();

Whith DQL when you write a join, it can be a filtering join (similar to the concept of join in SQL used for limiting or aggregating results) or a fetch join (used to fetch related records and include them in the result of the main query). When you include fields from the joined entity in the SELECT clause you get a fetch join. Here is the code for the StudentsService->getStudents() method:

$dql = "SELECT s, c, m, e FROM entities\Student s 

            JOIN s.country c JOIN s.marks m

            JOIN m.course e ORDER BY s.lastName, s.firstName";

$q = $this->entityManager->createQuery($dql);

return $q->getArrayResult();

Each student is retrieved along with the country he belongs to and all of his courses from the many-to-many table – all with a single DQL query. And if you print_r() the result you’ll see a structure along these lines:

In addition, when you create these kinds of queries with fetch joins and you use getArrayResult() method on the query object instead of getResult(), you get a nice array or associative array of other arrays. These data are ready to be sent to the Flex client without any transformation.

The only part I haven’t discussed is how I handle the changes for a Student. I will talk about this as part of the Flex client.

For the communication between the Flex and PHP side I’ll use remoting. On the PHP side I need Zend AMF in order to enable remoting. But for the purposes of this article I will let Flash Builder 4 handle this (installing Zend Framework and creating the gateway for exposing the four PHP services I created).

Creating the Flex client

With the server code in place, it is time to add the Flex code. In the previous article I wrote all client code manually. This time I’ll use the data-centric development features of Flash Builder to introspect PHP classes and create the service wrappers as well as the ActionScript value objects.

The easiest way to do this, is to first create the four services, and then to define the return types for the getStuff() operations. Follow these steps:

1. From the Data/Services view click the Connect to Data/Service link for the first service or on the third icon (the one with a + sign) for the other three services
2. When the wizard opens, select PHP, and click Next. If it is your first time using the wizard for PHP, then you’ll be presented with a dialogue to install the Zend Framework
3. Click Browse and select the first PHP service
4. Repeat these three steps until you have defined all the four services. Please note that you can change the packages where the services and the value objects will be created

Now, it is time to define the value objects I’ll use on the Flex side. Again I’ll use the data-centric development features:

1. Because the StudentsService returns a complex type that uses Student, Course, Country, and Mark it is important to start defining the return types first with CountriesService and CoursesService, then for MarksService, and finally for StudentsService
2. To define the return type for an operation on as service, expand the tree for the service, and right-click the operation (for example, select getCountries() from CountriesService) and choose Configure Return Type from the context menu. When the wizard opens, make sure the first option is selected on the first screen (Auto-detect the return type from the sample data) and click Next
3. On the second page you can enter a name for the value object class (for example Country)
4. The most complex type is the return type for the StudentsService.getStudents() method. For this one, on the second page of the wizard you need to expand the nodes and choose for the type column, the types you defined earlier (Course, Country, or Mark)

Here is how the Student value object is presented in the Data/Services view after finishing the above steps:

With the service wrappers and value objects in place, it is time to take care of the application UI and put these files to use. For this task I reuse most of the code I wrote in my previous application. I had to tweak some of the methods a little (for example, saveStudent() and onStudentSelection()).

When the application starts, the first thing I want it to do is load the courses, countries, and students. To do so, I created an init() function and registered it on the creationComplete event of the application. Then, I selected the getStudents() method from the Data/Services view, right-clicked it, and chose Generate Service Call. This command adds to the code an instance of StudentsService, an instance of CallResponder (you use this object to retrieve the result using the lastResult property or to register a result/fault listener for that operation), and a method that makes the call to the selected operation and assigns the token returned by the operation to the token property of the CallResponder object:

private function getStudents():void {

    getStudentsResult.token = studentsService.getStudents();

}

…

<s:CallResponder id="getStudentsResult"/>

<services:StudentsService id="studentsService"

fault="Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail)" showBusyCursor="true"/>

Another change from the first article is the use of bidirectional binding for the firstName, lastName, and registration fields of the form.

Here is the complete code of the Main.mxml where the magic happens:

<?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" xmlns:services="org.corlan.services.*"

               creationComplete="init()" xmlns:entities="org.corlan.entities.*">

    <fx:Declarations>

        <s:CallResponder id="getStudentsResult"/>

        <services:StudentsService id="studentsService" fault="Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail)" showBusyCursor="true"/>

        <s:CallResponder id="getCountriesResult"/>

        <services:CountriesService id="countriesService" fault="Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail)" showBusyCursor="true"/>

        <s:CallResponder id="getCoursesResult" result="onCourses()"/>

        <services:CoursesService id="coursesService" fault="Alert.show(event.fault.faultString + '\n' + event.fault.faultDetail)" showBusyCursor="true"/>

        <entities:Student id="student"/>

        <s:CallResponder id="deleteStudentResult" result="getStudents()"/>

        <s:CallResponder id="saveStudentResult" result="getStudents()"/>

    </fx:Declarations>

    <fx:Script>

        <![CDATA[

            import mx.collections.ArrayCollection;

            import mx.controls.Alert;

            import mx.events.FlexEvent;

            import mx.events.ListEvent;

            import org.corlan.entities.Country;

            import org.corlan.entities.Course;

            import org.corlan.entities.Mark;

            import org.corlan.entities.Student;

            private var marks:Array;

            private function onCourses():void {

                marks = new Array();

                var c:Array = (getCoursesResult.lastResult as ArrayCollection).toArray();

                for (var i:int=0; i<c.length; i++) {

                    marks.push(

                            {id : 0, mark : 0, course : c[i]}

                        );

                }

                dgMarks.dataProvider = marks;

            }

            private function customLabel(data:Object, column:DataGridColumn):String {

                var arr:Array = new Array();

                var c:int = (data as Student).marks.length;

                var mark:Mark;

                for (var i:int = 0; i<c; i++) {

                    mark = (data as Student).marks[i] as Mark;

                    arr.push(mark.course.name);

                }

                if (arr.length > 0)

                    return arr.join(", ");

                return "NONE";

            }

            private function init():void {

                getCountries();

                getCourses();

                getStudents();

            }

            private function getStudents():void {

                getStudentsResult.token = studentsService.getStudents();

            }

            private function getCountries():void     {

                getCountriesResult.token = countriesService.getCountries();

            }

            private function getCourses():void {

                getCoursesResult.token = coursesService.getCourses();

            }

            private function saveStudent():void {

                var m:Mark;

                student.marks = new ArrayCollection();

                for (var i:int = 0, l:int = marks.length; i<l; i++) {

                    if (marks[i]["mark"] > 0) {

                        m = new Mark();

                        m.course = marks[i]["course"];

                        m.mark = marks[i]["mark"];

                        student.marks.addItem(m);

                    }

                }

                student.country = country.selectedItem as Country;

                saveStudentResult.token = studentsService.saveStudent(student);

            }

            private function onStudentSelection(e:ListEvent):void {

                student = e.itemRenderer.data as Student;

                if (student.country) {

                    var l:int = getCountriesResult.lastResult.length;

                    for (var i:int = 0; i<l; i++) {

                        if (getCountriesResult.lastResult[i].id == student.country.id) {

                            country.selectedIndex = i;

                            break;

                        }

                    }

                }

                if (student.marks && student.marks.length > 0) {

                    var k:int = marks.length;

                    var o:Object;

                    for (var j:int = 0; j<k; j++) {

                        o = marks[j];

                        o["mark"] = 0;

                        for (var jj:int = 0; jj < student.marks.length; jj++) {

                            if ((student.marks[jj] as Mark).course.id == (o["course"] as Course).id) {

                                o["mark"] = student.marks[jj].mark;

                                break;

                            }

                        }

                    }

                    dgMarks.dataProvider = marks;

                }

            }

            private function deleteStudent():void {

                if (!student || !student.id)

                    return;

                deleteStudentResult.token = studentsService.deleteStudent(student);

            }

        ]]>

    </fx:Script>

    <mx:DataGrid id="dgStudents" x="13" y="14" dataProvider="{getStudentsResult.lastResult}"

                 itemClick="onStudentSelection(event)">

        <mx:columns>

            <mx:DataGridColumn headerText="First" dataField="firstName"/>

            <mx:DataGridColumn headerText="Last" dataField="lastName"/>

            <mx:DataGridColumn headerText="Country" dataField="country.name"/>

            <mx:DataGridColumn headerText="Courses" labelFunction="customLabel" width="200"/>

        </mx:columns>

    </mx:DataGrid>

    <s:Button click="getStudents()" label="Get Students" x="13" y="200"/>

    <s:Button x="112" y="200" label="New" click="student = new Student();"/>

    <s:Button x="190" y="200" label="Delete Selected Student" click="deleteStudent()"/>

    <mx:Form x="510" y="0">

        <mx:FormItem label="First:">

            <s:TextInput id="first" text="@{student.firstName}"/>

        </mx:FormItem>

        <mx:FormItem label="Last:">

            <s:TextInput id="last" text="@{student.lastName}"/>

        </mx:FormItem>

        <mx:FormItem label="Registration:">

            <mx:DateField id="registration" selectedDate="@{student.registration}"/>

        </mx:FormItem>

        <mx:FormItem label="Country:">

            <s:List id="country" dataProvider="{getCountriesResult.lastResult}" labelField="name" height="150"/>

        </mx:FormItem>

        <mx:FormItem label="Marks:">

            <mx:DataGrid id="dgMarks" editable="true">

                <mx:columns>

                    <mx:DataGridColumn headerText="Course" dataField="course.name" editable="false"/>

                    <mx:DataGridColumn headerText="Mark" dataField="mark" editable="true"/>

                </mx:columns>

            </mx:DataGrid>

        </mx:FormItem>

        <mx:FormItem>

            <s:Button label="Save" click="saveStudent()"/>

        </mx:FormItem>

    </mx:Form>

</s:Application>

Now, when I call the saveStudent() method I make a call to the remote operation (saveStudent() from the StudentsService.php) and pass along an instance of the Student ActionScript class. In the PHP method (StudentsService->saveStudent()) I get an anonymous Object, so I had to manually build an instance of the Student entity and populate it with the data. Here is the complete code for the server side saveStudent() method:

public function saveStudent($student) {

    if ($student->id) { //update

        $entity = $this->entityManager->find('entities\Student', $student->id);

        if (!$entity)

            throw new Exception('Error saving student!');

        $marks = $entity->getMarks();

        foreach ($marks as $mark) { //update mark value for existent records

            $found = false;

            foreach ($student->marks as $record) {

                if ($mark->getCourse()->getId() == $record->course->id) {

                    $mark->setMark($record->mark);

                    $found = true;

                    $key = array_search($record, $student->marks, true); //remove the $record from array

                    if ($key !== false)

                        unset($student->marks[$key]);

                    break;

                }

            }

            if (!$found) { //remove current mark

                $entity->removeMark($mark);

                $this->entityManager->remove($mark);//remove mark from database

            }

        }

    } else { //insert

        $entity = new entities\Student();

        $this->entityManager->persist($entity);

    }

    $this->addNewMarks($entity, $student); //add new marks if any

    $entity->setFirstName($student->firstName);

    $entity->setLastName($student->lastName);

    $d = new DateTime();

    $d->setTimestamp($student->registration->getTimestamp());

    $entity->setRegistration($d);

    $country = $this->entityManager->find('entities\Country', $student->country->id);

    if (!$country)

        throw new Exception('Error saving student; invalid country!');

    $entity->setCountry($country);

    $this->entityManager->flush(); //save the student

}

If you think it is way to much code for this “simple” operation, then I think you are partially right. In the Conclusions section I touch on this. However you have to remember that this code handles many things: creating a new student, and inserting its marks in the Marks2 table or updating a student and its marks from the Marks2 table if they were changed (new courses added, grade changes and so on).

Instead the delete method is quite clean (remember that behind the scene removes all the related records from the marks many-to-many table):

public function deleteStudent($student) {

    $entity = $this->entityManager->find('entities\Student', $student->id);

    if (!$entity)

        throw new Exception('Error deleting student!');

    $this->entityManager->remove($entity);

    $this->entityManager->flush();

}

Getting the source code

If you’re curious and you want to explore the code, you can download the project from here. It contains the PHP doctrine2_students folder, the database SQL dump for creating the tables, and the Flex code.

The easiest way to import this project is just to extract the folders (you import the project in Flash Builder). Then place the PHP code (doctrine2_students folder) inside of the web root folder. Get the Doctrine 2 files, and then reconfigure the doctrine2_students/bootstrap.php file to define the Doctrine 2 location and update the database credential. And finally, create a new Flex/PHP project, and repeat the first part of the article (creating the Flex wrapper services and value objects).

Conclusions

Overall, I think Doctrine 2 makes it easier to work on PHP and Flex projects. I especially love the new Data Mapper approach and its flexibility/power. The entities are very light and you can easily use DQL in conjunction with getArrayResult() to build a data structure ready for sending to Flex. Also there is no need for all the plumbing work I did for Doctrine 1 in order to send the objects on the PHP side. I encourage you to read the excellent documentation you’ll find on Doctrine site to better understand the inner workings, the different types of associations, and in general the features it offers.

With Doctrine 2 you get a big boost in terms of writing the PHP services and exposing the data to the Flex client. And if you think about it, the server side is not the place where the most the effort goes in. So it is a good thing to have a framework that standardize the PHP code and helps you big time when retrieving and persisting data. However, you can tell that it is not a framework architected with rich clients in mind (and there is nothing bad in this, I mean it’d be the same with the most of the frameworks out there). As easy it is retrieving data from the underlying persistence layer and sending them to a rich client, as hard persisting the client changes is. You have to write custom code to create the PHP entities out of the data received from the client before being able to persist the changes. What I feel it is missing is a way to use a data structure (for example an associative array) as the source for creating the PHP entities (more on this below).

Another interesting departure from the Doctrine 1 example is that I didn’t create an exact match between the ActionScript and PHP entities. When I designed the two sides of the equation, I had in mind the best domain model to serve the Flex client because all the information is edited on the client. Then I used the getArrayResult() method to send associative arrays to Flex (which are deserialized into Objects in Flex).

A feature I stayed away instinctively (both with Dotrine 1 and 2) was the ability to generate the database schema using the entities and the mapping between them. In other words, you could start your project first writing the PHP data model, and then use Doctrine to generate the database for you. I’m old school and all my experience taught me that relational databases treat you well if you treat them well. Thus, I much prefer to create the database with my “own” hands and make sure I set all the indexes/constraints I need. Having said this, I’m not saying that the Doctrine feature for generating database schema is buggy or worthless. I just wanted to explain why I haven’t tried. Your mileage could vary on this one.

The data-centric development features of Flash Builder simplified the creation of the data model a lot. I’m not sure if they work for any kind of project, but in this case I didn’t see any drawbacks.

You have very little work to do when handling the Delete and Read part of the CRUD operations on the server side. However, with Create/Update things change, especially when the object has associations (many-to-many, one-to-many, many-to-one with other entities). I thought it would be enough to retrieve the existing Student data from Doctrine and call the removeMark() method to remove a Mark. In fact, doing this doesn’t delete the entry from the many-to-many table. Instead, you have to explicitly remove the Mark instance from the Student and from the entityManager:

$student->removeMark($mark);

$this->entityManager->remove($mark);

Doctrine 2 offers a Cascade feature for persist/remove. For example, here I defined cascade delete/update for the Marks entities on the Student object:

class Student {

...

    /**

    * @OneToMany(targetEntity="Mark", mappedBy="student", cascade={"persist", "remove"})

    */

    private $marks;

...

}

However, I found that they actually work perfectly only on delete (see the previous paragraph for why I don’t believe the persist is fully functional). It is possible that I didn’t understand the usage, and I was expecting more than intended or I just messed up something…

Another small glitch was related to the composite primary keys. When I tried to follow Doctrine’s documentation and annotate the Mark entity to compose the primary key out of student_id and course_id, I got a runtime error. So I had to alter the table and add an auto increment primary key.

The only other thing I didn’t like was the date handling. When you send a Date object to the PHP side, on the PHP side you get a Zend_Date object (when using the Zend Framework). And because Doctrine 2 knows how to handle only the PHP DateTime object, you have to manually handle the transformation. It would be cool to either configure in some way Zend Framework to use PHP DateTime instead of Zend_Date or to have Doctrine 2 handle this for you :D

I had tons of fun while writing this article and playing with this new technology. I can say that Doctrine 2 rocks! If you give Doctrine 2 a try with Flex, please drop a comment with your impressions.

For the past six months we’ve been rolling out a lot of goodies, some of them in the form of final releases, others as betas. It’s no wonder you have to spend some time in order to get up to speed with the latest features of AIR 2, Flash Player 10.1 for Android, AIR 2.5, Flex 4, or Flash Builder 4. Thus, I thought it’d be a great idea to put together a list of resources to help you learn about these goodies.

So here I go, in no particular order.

Peer 2 Peer

Flash Player 10.1 and Adobe AIR 2 brings new capabilities to the table when it comes to Peer 2 Peer. The best resource to learn about this is my fellow evangelist Tom Krcha (some say his dreams are multicasted, but only a few are lucky enough to receive them :D):

• Multicast Explained in Flash Player 10.1
• File sharing over P2P in Flash Player 10.1 with Object Replication
• P2P GroupSpecifier Class Explained
• Direct Routing Explained in Flash Player 10.1
• Simple chat with P2P NetGroup in Flash Player 10.1

Flex and server side technologies

• Christophe Coenraets wrote about tuning client-side performance using Flex 4 and LiveCycle Data Services
• Ryan Stewart’s article on creating a basic CRUD application using Flex and PHP with Zend AMF
• If you prefer to use the Data Centric Development features of Flash Builder when working with Flex and PHP check out this article
• Debugging Flex and PHP projects with Flash Builder 4 and Eclipse PDT/XDebug
• Using Flash Builder 4 to build a Flex application that consumes a .NET-based web service written in C#

AIR 2

• Understanding the security changes in Flash Player 10.1 and AIR 2
• Creating a Web Server using the new Server Socket API in AIR 2
• Exploring the “open with default application” API
• Exploring the Native Processes API: here, here, here, and here
• Retrieving a list of network interfaces in Adobe AIR 2
• Creating a socket server in Adobe AIR 2
• Resolving DNS records in Adobe AIR 2
• Using drag-and-drop support of remote files in Adobe AIR 2
• Writing multiscreen AIR apps
• AIR 2 and Enterprise
• Developing AIR offline applications using the ColdFusion 9.0.1 ActionScript ORM Library
• Ten tips for building better Adobe AIR applications

AIR/Flash Player 10.1 and Android

• Mark Doherty’s P2P Video Calls on Android tutorial
• AIR 2.5 StageWebView demo
• Geolocation in AIR
• Video chat for Android using LiveCycle Collaboration Service and AIR
• Android apps that connects to desktop apps using Peer 2 Peer: here and here
• Setting up the tools for creating AIR for Android apps and accessing the camera from AIR
• Android Trader Desktop with Flex and AIR for Android
• “VoiceNotes for Android”: Sample App using Flex, AIR, and the Microphone API
• Serge Jespers’s native installers packager

Flex 4

• What’s new in Flex 4
• Differences between Flex 3 and Flex 4
• Skinning in Flex 4
• Introduction to Flex 4 (Spark) layouts
• New Animation Engine
• Michaël Chaize’s layout mirroring article
• Styling Flex 3 components with Flash Builder 4
• Image Zoom Effect and Animating Filters by Chet Haase

Other Flash Builder 4 related resources

• What’s new in Flash Builder 4
• Using Data-Centric features with Parsley (and other frameworks)
• Test Driven Development with Flash Builder 4 and FlexUnit
• Using Flash Builder’s Profiler
• Moving existing Flex projects from Flex Builder 3 to Flash Builder 4

Enjoy!

What is Melrose (formerly known as Shibuya)? It is a service provided by Adobe that helps you monetize your AIR applications. Pretty cool, isn’t it? Still, what exactly does it do for you? In a nutshell it helps you push your AIR application to millions of people and it handles all the details related to charging money for the application and setting up trial periods. From a code perspective, you add a library and couple of lines of code to your application to enable all these features.

For now, there are two storefronts available for you: Adobe AIR Marketplace and Intel AppUp center. You can use Melrose in 47 countries for now (it is still in private beta): Argentina, Australia, Austria, Belgium, Brazil, Bulgaria, Canada, Colombia, Cyprus, Czech Republic, Denmark, Estonia, Finland, France, Germany, Greece, Hungary, India, Ireland, Israel, Italy, Japan, Lithuania, Luxembourg, Malta, Mexico, Netherlands, New Zealand, Norway, People’s Republic of China, Poland, Portugal, Romania, Russia, Serbia, Singapore, Slovenia, South Africa, South Korea, Spain, Sweden, Switzerland, Taiwan, Turkey, Ukraine, United Kingdom and United States.

If you choose to charge money for your application, then you get 70% of the revenue (there is a minimum price of $2.99 for any app you want to sell). You get the money on a monthly basis, provided you sold for more than $100 in the past 30 days. There are no charges if you choose to give away your application for free.

And finally, you have access to a dashboard where you can see information like number of trials, number of purchases, and revenue.

You can sign up for Melrose here, on Adobe Labs. Sign up and let us know what do you think!

I thought it would be cool to talk about this app because chances are that you haven’t heard about Enterprise Cafe. So what is Enterprise Cafe? It is an AIR application (:D) that aggregates a big number of resources on the following topics: LiveCycle, Acrobat, Connect, ColdFusion, Flash Platform.

Once you log in using your Adobe ID account and choose, for example, the Flash Platform, you’ll see a screen like this:

Enterprise Cafe helps you to stay in touch with the community (you can access Adobe forums from this app), receive news (you’ll find the success stories posted here very interesting), check out the latest blog posts and videos using the incorporated RSS reader and Adobe TV section, or check for Adobe events.

If you want to convince your team or boss about the value of the Flash Platform, then you should definitely take a look at this app. You’ll find the information you need to convince them.

Install Enterprise Cafe

You can download the application from here.

Here is the second episode of the Flash Builder’s Lost Features show. This time I chose to talk about Flash Builder’s profiler and give you enough info to feel comfortable using it if it’s new to you. Profiler helps you to locate memory leaks, identify excessive object allocation, or analyze execution times.

With the extension of the Flash Platform on mobile devices, I think that it’s more important than ever to build Flash applications that run efficiently for a long time. Here is the video (you can watch the video in a higher resolution here).

If you want to read more about the “art” of profiling then please take the time to read the official (here and here) and Ilan Avigdor’s article.

This summer you have many contests to pick from if you want to create Flash content for mobile (Android 2.2) and win something while doing it. You can win fame/money/software/mobile devices — not neccesary in that order and not all at once– but you get the point :D.

For more details, check out these contests:

• Kongregate Mobile Flash Game Contest (almost $30,000 in prizes)
• Mochimedia Made for Mobile Contest ($20,000 in cash plus CS5 Master Suite licenses)
• Cell Your Flash Game ($30,000 in prizes)
• Adobe Czech Republic AIR Mobile Contest 2010 (Nexus One phones and software)

Good luck!

Lately, I’ve been thinking and working a lot with multiple-screen applications that run across desktop and Android devices. The reason for doing this is pretty simple: my first four computers were less powerful than the current smartphone I’m using these days.

And still I was doing far more things then I do with my phone now. So what are we using the smartphone for? I think we use a smartphone mainly for: making phone calls, Internet browsing, mailing, GPS, listening to music, and playing games. But is this all we can do? I think not.

One of my dreams is to be able to use my phone for tasks that I accomplished using the same tools 5-10 years ago. Let me give you some examples: we all have at home a number of remote controls: for the TV sets, DVD player, sound system, Air Conditioner system, TV set-top-box and the list could go on and on. The basic interaction between us and these devices hasn’t changed lately. Maybe you could replace some of these remote controls with an expensive one, touch based. This is only a compromise. We should be able to use our smartphones for these kinds of tasks and much more.

I mean we all carry the phones all day; they have beautiful screens and you can interact with them using the touchscreen interface. The biggest issue that prevents us from doing this is that most of the systems we are using today don’t talk the same language, nor do they offer a common API to interconnect them.

Hopefully this is starting to change. With the extension of the Flash Platform on smartphones (for now only on Android phones, but soon it will be available on other phones too) and on the TV sets/set-top-boxes we are one step closer to achieving a unified system. So instead of relying on manufacturers to expose a common API, we can leverage a common runtime that runs across devices. Imagine that you’d be able to use your smartphone for:

• Checking the current temperature in your home (even when you are not at home) and starting/stopping/reprogramming the AC
• Being able to change TV channels from your phone
• Being able to check the schedule and make a recording right from your phone
• Start recording a program on your way back home because you’ll be late and don’t want to miss the NBA final
• Controlling your music system from any room or even from your lawn
• Checking the grocery list your wife wrote two days ago while shopping

Some of these are already possible using some expensive home automation systems. Others are possible using a cloud solution. I think the ubiquity of the Flash Platform on a larger number of different devices and the huge number of Flash developers will make many of these available in the near future for everyone who cares and decides wisely what devices to buy.Why? Because on one hand it will be cheaper to develop a solution for multiple devices due to one common runtime and one language/framework to learn and, on the other hand, the Flash community is full of people who are not afraid to dream and who love to push the limits (just have a look at projects like Nexus One Wireless Slot Car Gas Pedal, Audiotool, Screenergy, or Creaza.com if you don’t believe me).

Until then, I will keep dreaming and try to build some of these myself. I’m looking forward to Google TV and the first TV sets that “speak” Flash.

What do you think?

LATER UPDATE: I’ve just seen this cool Android app build with AIR and Flex 4 that controls Freebox STB: http://chubby75.com/blog/?p=9

This week I had time to play with another idea for Android/Desktop applications: a picture viewer. My friend Alex Chiculita from the AIR team gave me this idea. A couple of weeks ago he played with a multi-screen application that let you load a picture from a device and send the picture to all the other devices connected to the same Wi-Fi network (the app runs on Android, Windows, MacOS, and Linux).

While playing with his application I realized that I could transform it into something more helpful (at least for me). Here is the challenge: we all use our smartphones for a lot of things, including taking pictures. Having a decent digital camera (this is what a smartphone became lately on top of a mobile phone) with you all the time means you can take interesting pictures. And usually you want to show these pictures to your friends or family. However, here is the problem: while taking pictures is extremely easy, sharing them involves cables,  Bluetooth, or seeing the picture on the phone’s screen.

My solution to this problem is AndroidPictures (the above pictures show AndroidPictures in action on my mobile). This Android application lets you browse through the pictures taken with the phone and scale/rotate/pan them. On the desktop, you use the companion AIR application for AndroidPictures, which displays the pictures sent by the Android application. All you have to do to see the pictures with your family is:

• connect your Android phone to the WI-FI network;
• start the AndroidPictures app on your Android phone, and start the PicturesViewer app on one of/all your computers;
• what you see on your mobile phone will be replicated on all connected computers.

Watch the video below to see how it works.

The making of

I used Adobe AIR and Flex 4.1 for creating the Android and desktop applications. In order to connect the Android application to the desktop apps I used Peer-to-Peer direct routing (the same approach used in my previous app). As I already explained, if your local subnet (for example your home Wi-Fi) supports broadcasting then you can create a NetConnection without using Stratus or a Flash Media Server (you connect the NetConnection to “rtmfp:”). This is one of the new features available in Flash Player 10.1 and Adobe AIR 2.

Once you have the clients connected, you can send messages from any one to all of them. And the cool thing about using this approach as opposed to Socket servers is that you don’t have to manually manage all the clients. Your program sends a message and the clients decide how to handle the message. You simply don’t care how many clients are connected. You can read more on my fellow evangelist Tom’s blog.

Because I wanted to use this approach for other apps, I created a simple library (you can get the library’s source code from here; unzip the archive and import the PeerToPeer.fxpl project in Flash Builder). You’ll find three ActionScript classes, and the magic happens inside of MultiCastingService class. The public interface of this service is:

• isReady
• neighborCount
• userName
• connect()
• disconnect()
• post()

The service throws these events:

• ServiceEvent.CONNECTED
• ServiceEvent.DISCONNECTED
• ServiceEvent.PEER_CONNECT
• ServiceEvent.PEER_DISCONNECT
• ServiceEvent.RESULT

The simplest way to use this service would be:

    var service:MultiCastingService = new MultiCastingService();
    service.addEventListener(ServiceEvent.RESULT, onResult);
    service.addEventListener(ServiceEvent.CONNECTED, onStatusChange);
    service.addEventListener(ServiceEvent.PEER_CONNECT, onStatusChange);

    service.connect();

    private function onResult(e:ServiceEvent):void {
        if (e.what == "picture") {
            //do something with the bytes: e.body
        }
    }

    private function onStatusChange(e:ServiceEvent):void {
        if (e.type == ServiceEvent.PEER_CONNECT) {
            if (service.neighborCount > 0) {
                //others are connected; send a String message
                service.post("this is my message");
            }
        }
    }

For the Android app I had to tweak the Spark List in order to make it works with both touch and click events. For the picture interaction I used a library created by Tim Kukulski, a member of the Adobe XD team. This library makes it easy to interact with pictures by letting you use gestures like zoom, pan, or rotate.

The desktop application waits and responds to two kinds of messages: picture bytes and pictures transformations (rotation, zooming, or panning). Every time a picture is selected in the Android app, I grab its bytes and send them through the “wire”. When I transform a picture in the Android app, I grab the Matrix and send it to all the connected clients. The client applies the Matrix on the picture. And the rest is history :)

All in all it was pretty easy to put together these apps and I had a lot of fun while doing this. If I have the time, I will try to see if I can play the movies recorded with my Android by extending the current code.

Getting the apps and source-code

You can download the source code from here, install the desktop application from here, and the Android application from here. If you want to run the Android application, you need to install Adobe AIR on your Android (more info here).

If you have ideas for more applications that take advantage of having AIR running on Android phones and desktops please let me know. If you create something interesting, I’d love to hear about. I already have another cool idea, this time more complex and even more fun!

Have fun with the Flash Platform on multiple screens!

Today, I finished a project I’ve been working since last week: a desktop MP3 Music Player that can be controlled by any number of Android phones. I built these apps using Adobe AIR and the Flex framework. Below you can watch a video with these apps in action, running on Motorola Droid, Nexus One, and my laptop (you can watch here the video in a higher resolution).

The communication between the remote controls (AIR apps running on Android phones) and  desktop player is done using the peer to peer features of AIR 2 and Flash Player 10.1. Basically if all the parties are connected to the same subnet and if the network allows broadcasting, then you can create a group and send messages to all the members without the need of Stratus or some other service/server.

Actually, while working on this project I created a small class that enables you to quickly create clients who connect to a local network. Of course, this is only one way of connecting two or more clients. You can use sockets if you want, or one-to-one communication (peer2peer). But I think in both these cases you have to work more, because you have to manually manage all the parties involved. If you want to find out more about peer2peer features of the Flash Platform take a look at this MAX session and read my fellow evangelist Tom Krcha’s blog.

The Android app was more fun to build because I used the touch input mode along with click input. I enjoyed a lot tweaking James Ward’s code for scrolling a Flex List. Believe it or not, again I used Illustrator and Flash Catalyst a lot to create the skins or parts of them.

Until I have the time to put together an article explaining  how these apps were created, please enjoy the video and play with the apps: desktop file and APK file. And from here you can download an archive with the source code. If you need the Adobe AIR runtime or AIR SDK for Android, please sign in for the pre-release group here.

What do you think?

Yesterday we announced Hero. This is the code-name for the next version of the Flex SDK. I think you’ll find the main themes for this release very interesting:

• Multi-Screen Development: Allow developers to build applications that target the web, desktop or mobile devices using a single unified framework.
• Spark Maturation: Polish and grow the Spark architecture by adding new Spark components and capabilities.
• Large-Application Development: Support developers building large applications by improving fundamental Flex infrastructure pieces.

Among the big news is that both mobile and desktop needs will be served by the same core Flex framework (Hero). Previously, we said that Slider (the code name for the Flex Mobile Framework we announced at Max 2009) would be a separate framework from the Flex SDK. I think this is excellent news; having one framework to target both worlds (mobile and desktop) means that you, the developer, have to spent less time learning and coding.

You can read more about these themes here.

For now there are no public builds for Hero. We are working on this and pretty soon we will have public builds. Keep an eye on this site for Hero white papers and builds.

If you haven’t seen these two projects, then please keep reading. I’m sure even if you are familiar with all kinds of cool rich Internet apps these two apps will surprise you. And to tell you the truth, I was surprised too. It seems that every now and then some cool projects pop up and they manage to move what is possible with the Flash Platform to a whole new level.

Enough talking, let’s start with the first project. Screenergy.com is a multi-touch 46″ full HD table with object tracking capabilities. Well, these specs are cool but not something to amaze you. Yet! They used this cool hardware as the platform to run AIR applications that allow people of any age and background to interact visually with a system that handles and displays loads of data. Basically, the system can recognize a specialized card you place on the table and display the information related to that card. You can move the card on the screen, and you can expand and change settings. Here are some pictures to help you better grasp the amazing interactivity that Screenergy provides:

This project was built for the Global Climate conference in Copenhagen (2009). And the visitors and VIPs were able to visualize the impact that different changes have on the climate. Here you can get a taste of the application and here is a video with the table in action:

I knew about this project from the beginning because the people who built it approached me back in October 2009. They told me “we want to build an application for a touch table using AIR for the UI, and the client is one of the organizations behind the Copenhagen’s Climate Change conference. We have about a month to do it! “. Then we talked about AIR 2 features (at that time it was in private beta) and how they could leverage AIR 2 features for their project. And then, before Christmas, I received an email from them telling me that the project was delivered on time and it was a success.

The second project, Creaza.com, is delivered as a web application using Flash Player. It is a suite of four programs: a mind-mapping tool, a movie editor, a sound editor, and an online comic tool for creating cartoons/digital stories. Funny,  I know the guys behind this project too :) I had the pleasure to meet them back in 2007 during a user interview around Flex Builder 2 at that time.

For me the most amazing product from this suite is MovieEditor. It is one thing to play video in the browser and a totally different thing to be able to create a movie inside the browser using a web application that is pretty close to desktop video editors in terms of features and performance. You can use this timeline-based video editor to create movies  complete with professional-looking titles, transitions, effects, animation, music, and narration. You can test this app here.

I think these two projects are not at all two lonely rain drops lost in an ocean. I strongly believe that this is the natural result of the maturity and power the Flash Platform has achieved. The Flash Platform truly makes easy things easy, and hard things possible. There are more than 3 million Flash developers according to Evans Data, and many of these developer started with the Platform in the past two years. There are tons of libraries, frameworks, and tools to pick from (both commercial and open-source). There are many companies and agencies with a lot of experience in building rich Internet applications.

In a nutshell, I’m seeing an ecosystem that is growing and innovating faster than ever. Thus, I’m sure that many more cool projects will cross my path and I’d be happy to talk about them. And remember, these two projects are not just a proof of concept; these are fully functional projects that make money. The companies who built them are not huge corporations – quite the contrary. But what they may lack in terms of money they make up in imagination and a belief that everything is possible!

What do you think?

Last week I had the pleasure to present to the first edition of gotoAndSki() conference, up north in Norway. During one of my sessions people said that it’d be a great thing if Adobe could present the Flash Builder new features in such a way that it makes easier to learn them. They suggested instead of just throwing big PDFs to the community, we could also have blog posts tackling one feature at a time. I think this makes sense; we are all too busy with current and upcoming projects to find the time to go through manuals.

So here I come and I start today a series of articles called Flash Builder’s Lost Features. Today I’ll present Call Hierarchy command. This command makes it easy to find all the places where a particular property/variable/function/method is used in your project. It works for ActionScript or Flex projects.

To use this feature, right-click the variable or method you are interested in and select Open Call Hierarchy.

When you do this, you should see in Flash Builder a new view (named Call Hierarchy) with all the occurrences of what you’ve selected. If you double-click an entry, Flash Builder will open the file where that entry can be found and you can inspect the code. Also, you can extend a node to see the call stack trace. And all of this can be done without having to run the project.

This is it for now. Like I said, it is a small and simple to use feature, but it is pretty powerful. In the next episode I will talk about Flash Builder’s Profiler.

I know it has been way too hot lately, especially here in Bucharest. I have good news. First, next week the weather is expected to be cooler.  And second, I plan to host a Flash Coffee Meetup in Bucharest! The event will take place next Tuesday (June 22nd) at Grand Cafe Galleron (near La Mama restaurant, P-ta Romana) starting at 5PM.

There are only 15 tickets so hurry up and use this link to register. I’ll pay for the coffee and bring an Android phone with Flash Player 10.1 and Adobe AIR installed on it. Thus we can enjoy a good cup of coffee on a cold day (something that we’ll pretty soon miss :D) and talk about the latest Flash Platform and mobile device news.

You can register here. See you next Tuesday.

The Adobe MAX Awards 2010 competition is open (the deadline for project submission is August 13th – hope you are not superstitious :D). This year’s categories are:

• Advertising and Branding
• Digital Publishing
• Enterprise/Government RIAs
• Entertainment
• Multiscreen
• Social Computing

Good luck!

This August (25th – 26th) if you live in India and you work in the IT field then you really should consider attending Adobe Flash Platform Summit 2010 in Bangalore, India.

This is a two day event, and more than 2000 people are expected with tens of sessions and international speakers. You can read more here and you can register here (you can save 60% if you register before June 25th). If you want to propose a session then hurry up because the window is closing on June 21st.

It seems this summer that webinars are highly fashionable. The App in a Week European webinar hasn’t finished yet, and we’ve announced another one: Going Multi-Screen with the Flash Platform. The webinars will take place between June 22nd – 24th and you can register here.

I guess after attending these webinars you should be ready to create multi-screen applications when Flash Player 10.1 and Adobe AIR will be available for the Android platform (now they are still in beta).

This is the complete schedule:

• Tuesday, June 22, 9AM – 10AM Pacific Time – Best practices in optimizing web content for Flash Player 10.1
• Tuesday, June 22, 1PM – 2PM Pacific Time – The quickest way to build cross-platform apps with AIR 2
• Wednesday, June 23, 9AM – 10AM Pacific Time – Rich Internet App development with Flash Builder 4 for Flash Player 10.1 and AIR 2
• Thursday, June 24 9AM – 10AM Pacific Time – Multi-screen web content development with Flash Pro CS5

Enjoy!

As I promised at the end of my webinar here I come with the projects I used:

• The starting project created using Flash Catalyst
• The finished project (Flex and PHP project)
• PSD file

You can use the Import > Flash Builder > Flex project wizard to import these two projects into Flash Builder. However, to make the second project work, you need to copy the PHP files from inside the project (you’ll find a folder named eva_services with a bunch of files) to the root of your PHP server. Next you have to create the database (there is an SQL dump inside the same folder) and change the connection credentials from eva_credentials/db.php to match your local settings). Actually you can read more about this in my article on Debugging Flex and PHP projects.

I know that I squeezed quite a lot in my webinar and I had to move quickly between the topics. But you don’t have to worry because you’ll find articles and screencasts below that go into great detail on all the topics I covered:

• Setting up XDebug and debugging Flex and PHP projects here
• Working with Doctrine, Zend Framework, and Flex here
• Working with Flash Builder’s DCD features on PHP projects here
• You’ll find many Flex and PHP articles and videos on the Flex and PHP section of Adobe Developer Connection site,
• If you want to read more about remoting and AMF using Zend Framework or AMFPHP here are two articles I wrote awhile ago: Zend Framework and AMFPHP
• Data Paging using DCD features here

Finally, the recordings for the webinars:

• Erase the Designer to Developer gap: Adding interactions to your design (Serge Jespers’s session)
• Connecting a Flex app to PHP services (my session)
• Connecting a web application to a J2EE backend using Flash Builder 4 (Michael Chaize’s session)
• Working with Flash CS5 components in your Flash Builder 4 project (Mike Jones’s session)
• Going multi-user with P2P in Flash Player 10.1 (Tom Krcha’s session)
• Developing multi-user applications with LiveCycle services (Tom Krcha’s session)
• Bringing web Applications to the desktop with AIR 2 (Piotr Walczyscyn’s session)
• Code once and run on multiple mobile devices (Mark Doherty’s session)
• Rapidly build, deploy, and maintain Internet apps with ColdFusion (Terry Ryan’s session)

Again, I want to thank all of you who took the time to attend my session. Until the next time, Ciao!

I realized that for us (Europeans) it is a little bit harder to get our hands on a Nexus One or Droid phone. So, if you have created an AIR app for Android and you don’t have a device to test it on we can meet at one of the next events I’m doing and I will let you do the testing. Maybe we can shoot a video too :)

For now, my schedule looks like this:

• June 2nd I’ll be in Cluj-Napoca Romania  attending a Flex Camp
• June 3rd – 5th Timisoara Romania, attending and speaking at Drupal Camp
• June 10th-12th Norway attending gotoAndSki()

If you live in Bucharest, just send me an email and we will figure out a date depending on when I’m not travelling.

Looking forward to seeing what you build :)

The first release of OSMF, 1.0 is out. This is great news for both developers and publishers. Using the components from OSMF you can build quickly high quality and fully featured video players. And if you think about this, it totally make sense. I mean if you are a publisher your main expertise is to create/distribute/monetize the content and not to create advanced video players. And if you are a developer then you get an excellent start using components that were already tested and supports the latest advancements from the Flash Platform (Flash Player 10.1, Flash Access 2.0, HTTP Dynamic Streaming).

OSMF gives you the blocks you need to build a modern and powerful video player. What if you just want an out of the box player? Well, you have to take a look at Strobe Media Playback then. This is a compiled SWF that gives you a video player created using the OSMF.

I just want to add one more thing: OSMF was developed by many parties, not only by Adobe. Others submitted plug-ins and code. I know my friends from Kaltura are one of them, but other big names like ESPN, Akamai, Brightcove.

You can find more here.

The entire European platform evangelism team worked hard to create great content for a webinar called App in a Week (June 7th-10th). What is it all about? In short: We will show you how you can create applications using various
techniques with the help of the Flash Platform. Basically you will see different tools at work (Flash Professional, Flash Catalyst, Flash Builder, Photoshop), different approaches (Flex, ActionScript, desktop, mobile or web apps) and different back-end technologies (PHP or Java).

Long answer: it’s really too long, so better sign up and join us. I’m sure you’ll find new things. Here is the complete schedule:

• June 7th – 12:00 – 13:00 GMT Erase the Designer to Developer gap: Adding interactions to your design with Serge Jespers
• June 7th – 15:00 – 16:00 GMT Connecting your design to PHP services with Mihai Corlan
• June 8th – 12:00 – 13:00 GMT Connecting a web application to a J2EE backend using Flash Builder 4 with Michael Chaize
• June 8th – 15:00 – 16:00 GMT Working with Flash CS5 components in your Flash Builder 4 project with Mike Jones
• June 9th – 12:00 – 13:00 GMT Going multi-user with P2P in Flash Player 10.1 with Tom Krcha
• June 9th – 15:00 – 16:00 GMT Developing multi-user applications with LiveCycle services with Tom Krcha
• June 10th – 12:00 – 13:00 GMT Bringing web Applications to the desktop with AIR 2.0 with Piotr Walczyscyn
• June 10th – 15:00 – 16:00 GMT Code once and run on multiple mobile devices with Mark Doherty

As you can see we set up the event to work well for Europeans :) You can register here!

If you watch the news or what’s happening at Google I/O 2010 chances are that Google TV is not a novelty anymore. However you may not know that Google TV uses Flash Player 10.1 (Google’s browser, Chrome, integrates Flash Player). This is something I know for sure I want. Being able to watch YouTube videos on my TV with my whole family, instead of huddling around a small computer screen, is really nice.

On the other hand, I can’t believe how fast the time flies and how fast the technology evolves and morphs these days. One year ago I was in Berlin talking with journalists for the first time about Digital Home, where the TV sets can handle both the web and regular TV shows.

Here you can see a video with Google TV running Flash content:

Today, at Google I/O 2010 we have announced a public beta of the Adobe AIR for Android. This means you can sign in for getting the bits and if you have a Google Nexus One phone you can install the runtime and then test the existent AIR apps for Android or create new ones.

So this makes the perfect moment for sharing my AIR app for Android that will come handy every time you have a dinner with others and want to split the bill. So grab the APK file from here,  make sure you have the Android SDK on your machine and the phone is connected to the computer through the USB cable, and then run this command in console :

adb install -r aTabSplitter.apk

If you don’t like command line, then you can use Serge Jespers AIR app for packaging AIR apps as native installers including APK files for Android. Check his blog post here.

You can get the AIR for Android bits from here (and find more about developing for Android with Adobe AIR).

If you play with my app and you have feedback, please drop a comment!

Last week I created my first ever mobile application. It is an AIR app for Android. The app is called aTabSplitter because ahh, it just helps you to split a restaurant bill between many people. Here are some screenshots with the two screens of the app:

Developing this small application was quite entertaining. But it teach me a few lessons too:

• You know the old saying “premature optimization is the root of all evil”. This is true for mobile apps too. You never know if some framework or workflow will do the job until you actually try. In my case, the common sense was telling me that Flex 4 framework being a desktop framework is to heavy for the mobile world. After trying it, I think actually it works quite good for me. Your mileage can vary.
• Developing for mobile is not easy at all. I spent almost my entire professional life building web applications for desktops. Doing mobile apps after this is like trying to create jewels miniatures with the skills of a mine worker. You need a different mind set; you need to acquire new skills.
• It is highly educational watching people using your app. Because of the touch-input nature of the mobile apps and the personal experience each user carries forward from previous devices/apps, you will certainly notice some interesting behaviors. With my app, a friend tried to remove a person (on the first screen) by throwing him outside of the screen. Needless to say that I didn’t think of this workflow, but it gave me an idea on how to improve the app.

Finally, this week I had the time to clean up the UI and code a little bit, and put together a video (the making-of type of video). Here is the video (you can watch the video in higher resolution here):

If you want to have a look at the code (although I warn you it is not production ready) you can download this project file. If you want to run this on a computer without a touch screen you need to make couple of changes (work with MouseEvents instead of TouchEvents, change root node in main.mxml from Application to WindowedApplication).

I can’t wait to have AIR for Android out and see what people will build!

Later Update: If you are looking for an article rather on Doctrine 2 than Doctrine 1, then check this one.

This year I finally had the time to play with Doctrine (version 1.x) and Flex. Actually, it was more than playing; I’m using it for a real project that hopefully will enter production pretty soon. To summarize the experience in just a few words: it’s mind-blowing.

OK, I admit I may be exaggerating a little bit. Still, it is something that can change the way you build projects. Doctrine is an ORM (Object Relational Mapper) framework for PHP and it can really speed up the server side development when you have a lot of tables in your database.
In this article, I explore how to work with Doctrine on the server side, Flex on the client side, and remoting to communicate between Flex and PHP (using the Zend Framework for remoting on the PHP side). I also want to share with you some tools and workflows that can save you some time. While most things are fairly straightforward there are a number of tips and tricks that you may find useful if you decide to go down this road. (I will show you how to use plain vanilla value objects and how to handle dates just to give you two examples. Why reinvent the wheel?)

The application I’m going to build in this article is simple but the workflow is the same one I used with a much more complex application. Having said that let’s start by understanding the big picture.

1. The Big Picture
2. Database Model
3. Installing Doctrine
4. Configure Doctrine and generate the model files
5. IDEs: Eclipse PDT and Flash Builder 4
6. Creating the PHP services and PHP value objects
   1. Getting the countries and courses
   2. Creating the StudentsService service
   3. Handling Create, Update, and Delete with Doctrine
7. Installing the Zend Framework
8. Setting up the gateway file
9. Creating the Flex front-end
   1. Creating the ActionScript value objects
   2. Creating the UI
10. Getting the source code
11. Conclusions

The Big Picture

Let’s see how these different pieces come together and play nice with each other like one big happy family. Have a look at Figure 1. Yeah, this is what you’ll get if you follow this article.

Breaking down Figure 1:

• On the right is a MySQL database to persist the data. You’ll see the data model in the next chapter.
• On the PHP server I use Doctrine to manage the tables in the database. I use Doctrine features to generate the model classes out of the database structure.
• On the PHP server I have a bunch of PHP services, which will be consumed from Flex using remoting. Typically for each table from the database there is a PHP class that provides, at a minimum, basic CRUD operations (Create/Read/Update/Delete).  These PHP services use the Doctrine model classes to read and persist the data. They are completely unaware of the database structure.
• Finally, we have plain vanilla PHP value objects. These may follow the structure of the database. The Doctrine models return instances of these value objects. The PHP services, when called from the Flex side, receive instances of these classes as arguments.
• The last piece on the PHP server is the Zend Framework. I use this framework to enable remoting for PHP (you could use AMFPHP, WebORB for PHP, or Sabre AMF as well). Basically it provides a gateway that represents the entry point to the PHP services for the Flex application.
• On the Flex side there are RemoteObjects that map to the PHP services.
• Then I have ActionScript value objects. For each PHP value object there is a corresponding ActionScript object. When using remoting the data is automatically changed to the right type based on the mappings you define.
• I can bind these ActionScript value objects to the different user interface elements in my application.

[Top]

Database Model

It is time to create the database. I’m going to use MySQL for the database. Every time I start a project that someday will be in production and uses a database I use data modeling software. Eight years ago the only viable solutions were Erwin or Power Designer (at least to my knowledge). I found that MySQL Workbench does a decent job and I use it fairly regularly nowadays (you can download MySQL Workbench from here).

Why use  database modeling software? It helps you design the database and all the dependencies, share the design with others, and quickly remember the database structure when you go back to the project after couple of months off. And it helps you a lot when you start to change the project as you are in the middle of it. Remember that I’m talking about projects that go into production, and I think there are very few of those that don’t undergo modifications, including changes to the database structure.

You can use MySQL Workbench to create a data model from scratch or reverse engineer an existing database. You can push all the changes you make to the model (new tables/fields/indexes) directly to the database. And, of course, you can print these models.

To start a new model, choose File > New and then click Add Diagram if you want to start from scratch. Then you can use the toolbox on the left to add tables and draw the relationships between them. When you double-click a table you can edit the name or add/edit fields and indexes. On the right side there is a Catalog viewer. By default the model will try to create the tables into a database named mydb. If you want to change the name of the database you can double-click on the current name from the Catalog view.

Once you’ve finished the design of the data model you can add a connection to your database server. The server can be on the localhost or a remote host, in the latter case you need to be careful if you have firewalls. Next use the Database > Synchronize Model wizard to push the new database model to the database server. You can use the same wizard whether you make changes to the data model and need them reflected to the database or you change the database and you want to push them to the data model.

You can download the model I created (see Figure 2) from here.

My application has four tables: students, countries, marks, and courses. A student can be registered to many courses and the mark (or grade) for each student for each course is stored in the marks table (a many-to-many table). Each student originates from a country, and there is a one-to-many relationship between the countries table and students table.

It is always a good practice to ensure that the data are consistent by using all the means a relational database offers (foreign keys, unique keys, and so on). I have unique keys for the name field in the countries and courses tables, on the first_name and last_name fields in the students table.

Now that I have the database in place and I can easy change it using the model, it is time to create the PHP classes that will handle these tables. Which means it is time for Doctrine to take the stage.

[Top]

Installing Doctrine

Doctrine is one of the few PHP ORMs (Object Relational Mapper) available. The current version (at the time of writing this article) is 1.2.2. You can download it from here. You can also get the library using SVN (here is the link for the repository; you need to look under the tags node).

Why should you consider using Doctrine (or any other ORM for that matter)? Usually, any change you make at the database level will require a change to the PHP code that handles that database. Doctrine can isolate you from these changes. How? It has a feature that lets you generate PHP classes that handle each table from the database, and the input for this feature can be the database itself.

Suppose you add a new table and two new fields in existing tables. You do this in MySQL Workbench, then you use the MySQL Workbench synchronize feature to push all these changes to the database. Next you use Doctrine to generate again the PHP classes that handle this database. In just a couple of minutes you have all the code you need to perform CRUD operations on your tables.

Doctrine also takes care of escaping the values, thus protecting you from SQL injection attacks. Another cool feature of Doctrine is DQL (Doctrine Query Language). This feature makes it easy to write complete queries.

You may be thinking that using the layers on top of PHP (Doctrine and the Zend Framework) can degrade the performance of your application, including how fast it responds to a request, how many clients can connect, and so on. While this is true theoretically speaking, in practice I’d say that the vast majority of projects don’t have performance issues. They have problems keeping up with design changes and new features.

Once you have the library files, create a new folder called doctrine_students under your web root folder. Inside of this folder create these folders: lib, lib/vendor, and lib/vendor/doctrine/. Next copy the Doctrine files to the doctrine_students/ lib/vendor/doctrine/  folder. If you downloaded the archive file, then you have to copy the folders and files from Doctrine-1.2.2/Doctrine-1.2.2/lib/ (there should be a Doctrine.php file and a Doctrine folder).

You can read more about installing Doctrine here.

[Top]

Configure Doctrine and generate the model files

The configuration of Doctrine is pretty simple. Basically you have to create a bootstrap file and include the Doctrine.php file, and then set the credentials for the database.

I created a file called bootstrap.php inside of the doctrine_students folder. This bootstrap file will be required in any PHP file that uses Doctrine. Inside of this file I added the following code:

<?php

//require the main file from Doctrine

require_once(dirname(__FILE__) . '/lib/vendor/doctrine/Doctrine.php');

//register the class autoloader function

spl_autoload_register(array('Doctrine', 'autoload'));

//create the singleton Doctrine_Manager instance

$manager = Doctrine_Manager::getInstance();

// enable automatic queries resource freeing

$manager->setAttribute(Doctrine_Core::ATTR_AUTO_FREE_QUERY_OBJECTS, true);

Next, create a new PHP file called generate_model.php inside of the doctrine_students folder and add this code as a simple test:

<?php

require_once('bootstrap.php');

echo Doctrine::getPath();

If you navigate to the doctrine_students folder in a terminal/console window and run generate_model.php you should see the absolute path to the doctrine folder:

mcorlan-mac:doctrine_students mcorlan$ php generate_model.php

/Applications/MAMP/htdocs/doctrine_students/lib/vendor/doctrinemcorlan-mac:doctrine_students mcorlan$

Create a new folder called models inside of doctrine_students. This is where Doctrine will generate the model files. Then go back to bootstrap.php file and add a new line at the end to create a database connection:

//create a connection

$conn = Doctrine_Manager::connection('mysql://mihai:mihai@127.0.0.1/students', 'doctrine');

Basically you set the connection type to mysql, then you set the user and password (in my case “mihai” for both) then you set the database IP (don’t use localhost even if you have MySQL installed on your local machine because it will not work), and finally you specify the name of the database to be used.

Back in the generate_model.php file, comment out the echo line and add these lines:

//generate the models from the DB schema in the models folder

Doctrine_Core::generateModelsFromDb('models', array('doctrine'), array('generateTableClasses' => true));

In your console, run php generate_model.php and you should find in the doctrine_students/models/ folder a bunch of files and another folder named generated. Basically you have a file with the same name for each table from your database. You will see in the next chapter how to use these model files to persist and retrieve data.

Having generated the model files, I want to load them by adding these lines to the bootstrap file (at the end of the file):

//include the models

Doctrine_Core::loadModels(dirname(__FILE__) . '/models/generated');

Doctrine_Core::loadModels(dirname(__FILE__) . '/models');

Doctrine offers another way for creating these model files: YAML schema files. You can write a schema file from scratch and then use this file for generating the models. Alternative, you can use the models you generated using the database structure to create a schema file and then edit this file before using it to regenerate the models.

If you want to create a schema file, just edit the generate_model.php file as follows (I commented the line that generates the model from the database and I added a new line that creates a YAML file from the models):

<?php

require_once('bootstrap.php');

//echo Doctrine::getPath();

//generate the models from the DB schema in the models folder

//Doctrine_Core::generateModelsFromDb('models', array('doctrine'), array('generateTableClasses' => true));

//generate the Doctrine Schema from models

Doctrine_Core::generateYamlFromModels('schema.yml', 'models');

Return to the console and execute the following command again: php generated_model.php. After this you’ll find a schema.yml file inside of doctrine_students folder.

With all the models in place, it is time to see how you can use these files to manage the database.

[Top]

IDEs: Eclipse PDT and Flash Builder 4

Up until now you could have used just about any text editor to complete the steps I’ve outlined. As the code you write gets more complex (and soon you will start to write Flex code as well), it is time to introduce you to my favorite setup for working on Flex and PHP projects: Eclipse PDT + Flash Builder 4 plug-in + XDebug (for enabling PHP debugging).

The easiest way to install Eclipse PDT and Flash Builder together is to first grab the Eclipse PDT and then install the plug-in version of Flash Builder on top of  Eclipse PDT. You can read more about how to install these products together here.

Now that you have support for both PHP and Flex projects, create a PHP project using the PHP new project wizard from Eclipse PDT (select the PHP perspective and choose File > New > PHP Project). I named the project students.

Then  add the doctrine_students folder to the project. Right-click the project name in Eclipse and choose New > Folder. When the wizard opens, click the Advanced button and then select the Link To Folder In The File System option. Next, click Browse, select the doctrine_students folder, and click Finish (see Figure 3).

Then create another two folders inside of doctrine_students folder: services and vo (see Figure 4).

[Top]

Creating the PHP Services and PHP value objects

It is time to create the PHP services. I’ll use the model files that Doctrine generated earlier.

First I will create a PHP class with two methods: getCourses() and getCountries(). In many applications you have some tables that stores data that almost never changes, for example lists of countries or cities. For such tables, you don’t need to implement CRUD operations you just need the read method. This is the case with the courses and countries tables.

[Top]

Getting the countries and courses

Create a file named CatalogService.php inside the doctrine_students/services/ folder and add this code:

<?php

require_once(dirname(__FILE__) . '/../bootstrap.php');

class CatalogService {

    public function getCourses() {

        $q = Doctrine_Query::create()

                ->select('*')

                ->from('Courses')

                ->orderBy('name');

        $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

        return $ret;

    }

    public function getCountries() {

        $q = Doctrine_Query::create()

                ->select('*')

                ->from('Countries')

                ->orderBy('name');

        $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

        return $ret;

    }

}

If this is your first time using Doctrine you’ll probably find this code both strange and familiar at the same time.

As I said earlier, Doctrine offers a query language (DQL). You can learn more about DQL here. The code above uses DQL to retrieve all the records from the courses and countries tables. Some things to remember:

• When you set the from clause (for example, ->from(‘Countries’)) you don’t specify the actual table name but the name of the model PHP class generated by Doctrine to manage that table. In this case it happens to have the same name and the first letter is capitalized.
• DQL works with objects and generates objects or graphs of objects.
• You can control the result format for a query by setting the second parameter of the execute() method on Doctrine_Query. I want to have the result sets as arrays or associative arrays. You could have your own hydration method or you could use one of the built-in hydrators.
• If you want to see the actual SQL that is executed you can call this method: $q->getSqlQuery().

Add some records to the courses and countries tables or use this script to create the database.

Now, you’re ready to test this code. Usually I do this before trying to connect to the PHP code from a Flex application. Just add some simple code at the top of this file in order to initialize the CatalogService object and call the two methods:

$service = new CatalogService();

print_r($service->getCourses());

print_r($service->getCountries());

If you run CatalogService.php in the browser you should see  the courses and countries used in the two tables (see Figure 5).

I have the first service in place, but I’m not entirely satisfied with the way my service works. I want to use some simple value objects to wrap each record instead of having an array of associative arrays like I have now.

I create two value objects called Country and Course in the doctrine_students/vo/ folder:

<?php

//Country.php

class Country {

    public $id;

    public $name;

}

<?php

//Course.php

class Course {

    public $id;

    public $name;

}

Now I just have to create a function that transforms the arrays I get from the Doctrine_Query object into arrays of value objects. You could achieve this by creating a custom hydration method or processing the result you get from the array hydration method.

Here’s how I did it. I created a function called  prepareForAMF that accepts two arguments. The first is the array you get using the Doctrine_Query object and the second is an array of objects to be used to wrap the associative array. From this array the function retrieves the types it has to use to transform the associative array into objects.

Here is the code for this function:

function prepareForAMF($data, $arrTypes) {

    if (count($data) == 0)

        return $data;

    $ret = array();

    $substract = false;

    if (!array_key_exists('0', $data)) {

        $data = array($data);

        $substract = true;

    }

    for ($i=0; $i<count($data); $i++) {

        $o = new $arrTypes[0]();

        foreach ($data[$i] as $property => $value) {

            $pproperty = strtolower($property);

            if (!property_exists($o, $pproperty)) {

                continue;

            }

            if (array_key_exists($property, $arrTypes)) {

                if ($value == NULL) {

                    $o->$property = array();

                    continue;

                }

                $newArr = $arrTypes;

                $newArr[0] = $arrTypes[$property];

                $o->$pproperty = prepareForAMF($value, $newArr);

            } else {

                $o->$pproperty = $value;

            }

        }

        $ret[] = $o;

    }

    if ($substract)

        $ret = $ret[0];

    return $ret;

}

I chose to declare this function in the bootstrap.php file because this file is already included in all the PHP services.

Having this function defined I rewrote the methods from CatalogService like this:

public function getCourses() {

    $q = Doctrine_Query::create()

            ->select('*')

            ->from('Courses')

            ->orderBy('name');

    $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

    $ret = prepareForAMF($ret, array(0 => 'Course'));

    return $ret;

}

public function getCountries() {

    $q = Doctrine_Query::create()

            ->select('*')

            ->from('Countries')

            ->orderBy('name');

    $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

    $ret = prepareForAMF($ret, array(0 => 'Country'));

    return $ret;

}

Next you need to include the two value objects in the CatalogService.php class by adding these lines at the top of it:

require_once(dirname(__FILE__) . '/../vo/Country.php');

require_once(dirname(__FILE__) . '/../vo/Course.php');

If you run CatalogService.php in the browser you’ll see the courses and countries are now listed as objects (see Figure 6).

Note: In Doctrine 2.0 (the upcoming version of Doctrine) support for plain vanilla value objects and for AMF remoting is planned and this trick/hack will not be needed. This is actually the reason why I didn’t bother to write my own hydration method. I’m planning to do a test run with the nightly builds soon.

[Top]

Creating the StudentsService service

It is time to move on and create another service for the students and marks tables. Create a file inside of doctrine_students/services/ folder named StudentsService.php.

Here is a blue print of the StudentsService class:

<?php

require_once(dirname(__FILE__) . '/../bootstrap.php');

require_once(dirname(__FILE__) . '/../vo/Country.php');

require_once(dirname(__FILE__) . '/../vo/Course.php');

$service = new StudentsService();

print_r($service->getAll());

class StudentsService {

    public function getAll() {

    }

    public function save($record) {

    }

    public function delete($record) {

    }

}

Let’s start by filling in the getAll() method. It will use the DQL feature to retrieve not only all the students, but also the country set for each student and all the marks he has (at this point you need to have some data in the students and marks tables):

public function getAll() {

    $q = Doctrine_Query::create()

                ->select('s.*, m.*, c.*')

                ->from('Students s')

                ->leftJoin('s.Marks m')

                ->leftJoin('s.Countries c')

                ->orderBy('s.last_name, s.first_name');

        $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

        return $ret;

}

Save the file and run it in the browser. If you choose view source you should see an array of arrays (see Figure 7).

Notice that for each record from the students table I retrieve all the records from the marks table (student_id = id) and the country record  from the countries table (country_id = id). This works because Doctrine takes into account all the relations between the tables when it creates the models.

Because I defined a one-to-many relation between the countries and students tables (a country can be assigned to any number of students) and a many-to-many table (marks) between the students and courses tables (each student can have a mark for each course), Doctrine generated the model (schema.yml) and model classes to support this database schema. Indeed if you open the doctrine_students/schema.yml file and look at the Students entry you’ll see that it has defined two relations: Countries and Marks.

These two relations have the same name as the two fields you saw when you ran the StudentsService->getAll() method.

Next you’ll need to create two value objects (Student and Mark) to use with StudentsService. Add these two classes to the doctrine_students/vo/ folder:

<?php

//Stundent.php file

class Student {

    public $id;

    public $first_name;

    public $last_name;

public $registration;

    public $marks;

    public $countries;

}

<?php

//Mark.php file

class Mark {

    public $student_id;

    public $course_id;

    public $mark;

}

Don’t forget to include these two new classes in the StudentsService.php file.

Now I’ll change the getAll() method to transform the array I get from the Doctrine query into an array of value objects:

//StundentsService class definition

...

private $types = array (0 => 'Student', 'Countries' => 'Country', 'Marks' => 'Mark');

public function getAll() {

    $q = Doctrine_Query::create()

            ->select('s.*, m.*, c.*')

            ->from('Students s')

            ->leftJoin('s.Marks m')

            ->leftJoin('s.Countries c')

            ->orderBy('s.last_name, s.first_name');

        $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

        $ret = prepareForAMF($ret, $this->types);

        return $ret;

}

...

Note: The prepareForAMF function works recursively as long as you provide the right mapping between the keys of the arrays and the value objects it needs to create. This time I defined these mappings as a class variable ($types).

If you run the code again you should now see arrays of value objects: Student, Mark, and Country.

There’s something else I want to fix. The registration field from the students table has the Date type. But in the array returned by the getAll() method it is a String. I want to make sure that this field is actually an instance of the DateTime class. This will pay dividends later on when I retrieve these records in the Flex client, because it will receive value objects that have the Date type for the registration field instead of String.

The best place to do this transformation is probably inside the prepareForAMF() function. I added an optional third argument that is an array of the fields that have Date or DateTime type. So here is the modified function:

function prepareForAMF($data, $arrTypes, $arrDates=NULL) {

    if (count($data) == 0)

        return $data;

    $ret = array();

    $substract = false;

    if (!array_key_exists('0', $data)) {

        $data = array($data);

        $substract = true;

    }

    for ($i=0; $i<count($data); $i++) {

        $o = new $arrTypes[0]();

        foreach ($data[$i] as $property => $value) {

            $pproperty = strtolower($property);

            if (!property_exists($o, $pproperty)) {

                continue;

            }

            if (array_key_exists($property, $arrTypes)) {

                if ($value == NULL) {

                    $o->$pproperty = array();

                    continue;

                }

                $newArr = $arrTypes;

                $newArr[0] = $arrTypes[$property];

                $o->$pproperty = prepareForAMF($value, $newArr, $arrDates);

            } else {

                if ($arrDates && array_key_exists($pproperty, $arrDates)) {

                    $o->$pproperty = new DateTime($value);

                } else {

                    $o->$pproperty = $value;

                }

            }

        }

        $ret[] = $o;

    }

    if ($substract)

        $ret = $ret[0];

    return $ret;

}

Then I add a third argument when calling the prepareForAMF() function inside of getAll():

//StundentsService class definition

...

private $dates = array('registration' => 1);

public function getAll() {

    $q = Doctrine_Query::create()

            ->select('s.*, m.*, c.*')

            ->from('Students s')

            ->leftJoin('s.Marks m')

            ->leftJoin('s.Countries c')

            ->orderBy('s.last_name, s.first_name');

        $ret = $q->execute(null, Doctrine_Core::HYDRATE_ARRAY);

        $ret = prepareForAMF($ret, $this->types, $this->dates);

        return $ret;

}

...

[Top]

Handling Create, Update, and Delete with Doctrine

It is time to write the StudentsService methods for creating, updating, and deleting records. For this, you need to fill in the blanks for the other two methods  defined earlier: save() and delete(). Please notice:

• I want to use the save() method for both creating new records and updating existing ones.
• The save() method receives one argument: an instance of a Student value object. If you want to add marks for the student you have to have Mark objects stored in the mark property.
• The save() method will add or change the related records from the marks table for the current student .
• The delete() method deletes all the related records from the marks table first and then the student (it is transaction safe).

Here is the code for save():

public function save($record) {

        $record = makeArrayFromObject($record, $this->dates);

        //update an existent student

        if ($record['id'] > 0) {

            //retrieve the current student model

            $o = Doctrine_Query::create()

                ->select('*')

                ->from('Students')

                ->where('id = ?', $record['id'])

                ->fetchOne();

            if (!$o)

                return false; //exit if there is no student

            //loading relations

            $o->Marks;

            //clean up the array

            $record['Marks'] = $record['marks'];

            unset($record['marks']);

            if (array_key_exists('countries', $record)) {

                //set the country id

                $o->country_id = $record['countries'][0]['id'];

                unset($record['countries']);

            }

            //modify the existent student data 

            //using the data we have in $record 

            $o->synchronizeWithArray($record);

        //insert a new student

        } else {

            $o = new Students();

            //load the main properties from the $record

            $o->fromArray(cleanRefences($record, $this->types));

            //add marks records for the student if any

            if ($record['marks']) {

                foreach ($record['marks'] as $val) {

                    $t = new Marks();

                    $t->fromArray($val);

                    $o->Marks[] = $t;

                }

            }

            //setting student's country id

            if (array_key_exists('countries', $record) && count($record['countries']) > 0) {

                $o->country_id = $record['countries'][0]['id'];

            }

        }

        //persist the data model to the database

        $o->save();

        //loading Countries relations

            $o->Countries;

        $ret = prepareForAMF($o->toArray(), $this->types, $this->dates);

            return $ret;

    }

And here is the code for two functions I use in the save() method (I declared these functions in the bootstrap.php file):

function makeArrayFromObject($data, $arrDates=NULL)

{

    $data = (array)$data;

    foreach ($data as $k => $v) {

        if (is_array($v)) {

            $data[$k] = makeArrayFromObject($v, $arrDates);

        } else {

            if ($arrDates && array_key_exists($k, $arrDates)) {

                if ($v instanceof DateTime) {

                    $data[$k] = $v->format('Y-m-d');

                } else {

                    $data[$k] = $v->toString('Y-M-d');

                }

            } else if (is_object($v)) {

                $data[$k] = (array)$v;

            }

        }

    }

    return $data;

}

function cleanRefences($data, $references)

{

    foreach ($references as $key => $val) {

        if (array_key_exists($key, $data)) {

            $data[$key] = NULL;

        }

    }

    return $data;

}

There are comments in the code so it should be easy to read and understand. I’ll explain just the parts I think are important:

• First of all, as I said earlier, Doctrine 1.x doesn’t have support for plain vanilla value objects. This is why the first thing I do is to transform the Student value object into an associative array using the makeArrayFromObject() function.
• When I update an existing record I use DQL to create an instance of Students. Once I have the Students object for the given ID, I want to load all the related marks records (by calling $o->Marks). Next I use the synchronizeWithArray() method to apply the changes from the $record array to the existing data (basically synchronizeWithArray() receives an associative array similar in structure to the one you get when using the Array hydration method on the same object). Finally I set the country id, and once I call the save() method on the Students object ($o->save()) the data are persisted.
• When I add a new record, I instantiate a Students object and then I use the fromArray() method to load the data from the $record array. However I found a glitch: for some reason it doesn’t work with the relations (in my case it didn’t save the related records to the marks table). So the workaround I found is to use the fromArray() method to load only the properties stored in the same table (students). This is why I clean the array from all the relations (Marks and Countries) using a call to the cleanReferences() function. I add the Marks objects manually using a for() loop.
• When adding marks records, it is interesting to note that Doctrine takes care of all the plumbing work for me. Suppose you add a new student and at the same time two marks: (course_id:1, mark:10) and (course_id:3, mark:9). The marks table has a third field student_id. When you call the save() method on the Students object, Doctrine will insert a new record in the students table, it will retrieve the id and then fill in the missing student_id for the two Mark records and then insert these two records.

The code for the delete() operation is much simpler. I use DQL to first delete all the related records from the marks table and then I delete the student record using an instance of Students. I make use of Doctrine support for transactions to keep the data consistent.

//StudentsService class definition

...

public function delete($record) {

        $record = makeArrayFromObject($record, $this->dates);

        //delete all related records from marks table

        $q = Doctrine_Query::create()

                ->delete('Marks')

                ->where('student_id = ?', $record['id']);

            //start transaction        

            $q->getConnection()->beginTransaction();

            $q->execute();

        $o = new Students();

        $o->assignIdentifier($record['id']);

        $o->delete();

        $q->getConnection()->commit(); //commit transaction

        $ret = prepareForAMF($o->toArray(), $this->types, $this->dates);

            return $ret;

    }

...

You now have all the code in place. If you want to verify it you can add testing code (the lines below) in the StudentsService.php file. Then run the file in the browser and then check the database:

$service = new StudentsService();

$c = new Country();

$c->id = 1;

$m1 = new Mark();

$m1->course_id = 3;

$m1->mark = 7;

$m2 = new Mark();

$m2->course_id = 4;

$m2->mark = 8;

$s = new Student();

$s->first_name = 'Michael';

$s->last_name = 'Doherty';

$s->registration = new DateTime('2010-03-14');

$s->countries = $c;

$s->marks = array($m1, $m2);

print_r($service->save($s));

Before moving on, don’t forget to comment (or delete) all the code you added in the service classes for testing.

[Top]

Installing the Zend Framework

The next task I have to complete on the PHP side is to enable support for remoting in PHP. I chose to do so by using the Zend Framework. You can use AMFPHP, WebORB for PHP, or SabreAMF as well.

Download and unzip the framework somewhere on your disk. Then use the php.ini file to include the framework:

include_path = ".:/Applications/MAMP/bin/php5/lib/php:/Applications/MAMP/zend_framework/library "

Save the file and restart the server. If you don’t have access to the php.ini you probably have to copy the whole framework under your web root, though this is not recommended for production.

[Top]

Setting up the gateway file

The last step I have to complete on the PHP side before moving to Flex is to create the gateway file. This file will represent the end point for all the remoting calls from the Flex application. It will configure and start the Zend AMF server.

Create a new file called gateway.php inside of doctrine_students folder and then add this code:

<?php

require_once('Zend/Amf/Server.php');

//create an instance of Zend AMF server

$server = new Zend_Amf_Server();

//adding the services folder in order to expose

//CatalogService and StudentsService

$server->addDirectory(dirname(__FILE__) . '/services/');

//Mapping the ActionScript VO to the PHP VO

//you don't have to add the package name

$server->setClassMap("Country", "Country");

$server->setClassMap("Course", "Course");

$server->setClassMap("Mark", "Mark");

$server->setClassMap("Student", "Student");

$server->setProduction(false);

echo($server -> handle());

Save the file and run it in the browser. You should either see the message “Zend Amf Endpoint” or a save dialog.

[Top]

Creating the Flex front-end

With all the PHP code in place, it is time to create the Flex front-end. From a workflow perspective you have two options:

• You can create a separate Flex project and have two projects in place: one for Flex and one for PHP.
• You can add Flex nature to the PHP project and use the same project for both Flex and PHP.

I usually prefer the second approach because I work on both Flex and PHP code and it is simple to debug them together.

To add Flex nature to the students project, right-click on the project name in Eclipse, and select Add/Change Project Type > Add Flex Project Type. When the wizard opens, select PHP as the application server type and click Next. Fill in the path to the web server root and URL to reach the root, then click Validate Configuration and then Finish. You might see this error in the Problems view: “Cannot create HTML wrapper. Right-click here to recreate folder html-template.” Just right-click on it and choose Recreate Folder HTML-template.

This wizard will create an MXML file named students.mxml as well. Open this file if you haven’t already and add the following code inside the <fx:Declarations> tag:

<s:RemoteObject id="catalogService" source="CatalogService" destination="zend"

                endpoint="../doctrine_students/gateway.php"

                result="onResult(event)" fault="onFault(event)">

    <s:method name="getCourses" />

    <s:method name="getCountries" />

</s:RemoteObject>

<s:RemoteObject id="studentsService" source="StudentsService" destination="zend"

                endpoint="../doctrine_students/gateway.php"

                result="onResult(event)" fault="onFault(event)">

    <s:method name="getAll" />

    <s:method name="save" />

    <s:method name="delete" />

</s:RemoteObject>

The code defines two remoteObjects, one for each service on the PHP side: CatalogService and StudentsService. I added the methods for clarity, although this is not mandatory. Note that the endpoint attribute points to the gateway.php file  created earlier.

The next step is to define the onResult and onFault event listeners. Add this code above or below the <fx:Declaration> tag:

<fx:Script>

    <![CDATA[

        import mx.rpc.events.FaultEvent;

        import mx.rpc.events.ResultEvent;

        private function onResult(e:ResultEvent):void {

        }

        private function onFault(e:FaultEvent):void {

        }

    ]]>

To test the code you’ll need to add a button and call one of the service’s methods on click. Next, add two breakpoints on the first line where each event listener is defined and then run the project in debug mode.

"catalogService.getCourses()"/>

After the page loads, click the button and in Eclipse you should see the Flex debugger stopped (see Figure 8).

[Top]

Creating the ActionScript value objects

When using remoting it is usually a good idea to create value objects on the Flex side that correspond to the value objects you have on the server side. In my case I need to create four value objects: Student, Mark, Course, and Country. I place all these classes in the org.corlan.vo package.

The code is here:

package org.corlan.vo {

    [Bindable]

    [RemoteClass(alias="Country")]

    public class Country {

        public var id:int;

        public var name:String;

    }

}

package org.corlan.vo {

    [Bindable]

    [RemoteClass(alias="Course")]

    public class Course {

        public var id:int;

        public var name:String;

    }

}

package org.corlan.vo {

    [Bindable]

    [RemoteClass(alias="Mark")]

    public class Mark {

        public var student_id:int;

        public var course_id:int;

        public var mark:Number;

    }

}

package org.corlan.vo {

    [Bindable]

    [RemoteClass(alias="Student")]

    public class Student {

        public var id:int;

        public var first_name:String;

        public var last_name:String;

        public var registration:Date;

        public var countries:Country;

        private var _marks:Array;

        public function get marks():Array {

            return _marks;

        }

        public function set marks(value:Array):void {

            for (var i:int=0; i

                value[i] = value[i] as Mark;

            }

            _marks = value;

        }

    }

}

There is nothing special to these value object classes. I’m using the Bindable metadata to make each property bindable and I use the RemoteClass metadata to tell AMF which is the corresponding class on the server side. On the PHP side I have the mapping defined inside of the gateway.php file using the setClassMap() method from AMF server - $server->setClassMap("Country", "Country");.

For the Student value object I use the getter/setter to cast the array of objects received from the server to an array of Mark value objects.

Before testing the code you need to make sure that these four value object classes are included in the compiled SWF. You can simply add these lines in the students.mxml file:

import org.corlan.vo.*;

static public var clz:Array = [Country, Course, Mark, Student];

If you run the project and call the studentsService.getAll() method when clicking on the button, you should see the value objects in the Flex debugger (see Figure 9).

[Top]

Creating the UI

Now you can focus on the UI of this application. It will be a simple UI with a data grid for displaying all the students (see Figure 10). When a student is selected from the data grid, the form on the right is populated and you can use it to change details for the current student. If you want to delete a student, just select a row and click Delete. If you want to add a new record, click New and then fill in the form.

I have a function that is used for creating the text in the courses column, and a bunch of arrays I’m using to store the data models (courses, countries, and students).

Here is the code for the application:

"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="init()" xmlns:vo="org.corlan.vo.*">

        

            [Bindable]
            private var arrStudents:ArrayCollection;
            [Bindable]
            private var arrCourses:ArrayCollection;
            [Bindable]
            private var arrCountries:ArrayCollection;

            private var coursesHash:Object;
            private var marks:Array;

            private function init():void {
                catalogService.getCourses();
                catalogService.getCountries();
            }

            private function getStudents():void {
                studentsService.getAll();
            }

            private function onStudents(e:ResultEvent):void {
                arrStudents = new ArrayCollection(e.result as Array);
            }

            private function onCourses(e:ResultEvent):void {
                arrCourses = new ArrayCollection(e.result as Array);
                //save the courses into a hashmap
                var l:int = arrCourses.length;
                coursesHash = new Object();
                marks = new Array();
                var c:Course;
                for (var i:int = 0; i
                    c = (arrCourses[i] as Course);
                    coursesHash
[/c]

 = c.name;
                    marks.push({course_id : c.id, mark : 0, name : c.name});
                }
                dgMarks.dataProvider = marks;
            }

            private function onCountries(e:ResultEvent):void {
                arrCountries = new ArrayCollection(e.result as Array);
            }

            private function onFault(e:FaultEvent):void {
                Alert.show(e.fault.faultDetail, "Error!");
            }

            private function onSelection(e:ListEvent):void {
                student = e.itemRenderer.data as Student;
                if (student.countries) {
                    var l:int = arrCountries.length;
                    for (var i:int = 0; i<l; i++) {
                        if (arrCountries[i].id == student.countries.id) {
                            country.selectedIndex = i;
                            break;
                        }
                    }
                }

                if (student.marks && student.marks.length > 0) {
                    var k:int = marks.length;
                    var o:Object;
                    for (var j:int = 0; j<k; j++) {
                        o = marks[j];
                        o["mark"] = 0;
                        for (var jj:int = 0; jj < student.marks.length; jj++) {
                            if (student.marks[jj].course_id == o["course_id"]) {
                                o["mark"] = student.marks[jj].mark;
                                break;
                            }
                        }
                    }
                    dgMarks.dataProvider = marks;
                }
            }

            private function customLabel(data:Object, column:DataGridColumn):String {
                var arr:Array = new Array();
                var c:int = (data as Student).marks.length;
                var mark:Mark;
                for (var i:int = 0; i<c; i++) {
                    mark = (data as Student).marks[i];
                    arr.push(coursesHash[mark.course_id]);
                }
                return arr.join(", ");
            }

            private function saveStudent():void {
                //set the marks