<mx:Script>
<![CDATA[

[Bindable]
private var authorsCollection:ArrayCollection = new ArrayCollection();

private function getData():void {
    myService.fill(authorsCollection);
}

private function save():void {
    myService.commit();
}

private function addNewItem():void {
    authorsCollection.addItem(new YourValueObject());
    myService.commit();
}

private function deleteItem():void {
    authorsCollection.removeItemAt(1);
    myService.commit();
}

private function faultListener(event:FaultEvent):void {    Alert.show(event.fault.message, event.fault.name);}

]]>

</mx:Script>
<mx:Button label="Revert" click="myService.revertChanges()"/>

<PHPDataService id="myService" destination="Author" source="Author"
        endpoint="http://localhost/amfphp/gateway.php" fault="faultListener(event)"/>

package org.corlan {

    [RemoteClass(alias="org.corlan.VOAuthor")]
    [Bindable]
    public class VOAuthor {

        public var id_aut:int;
        public var fname_aut:String;
        public var lname_aut:String;
    }
}

package org.corlan {
    import flash.events.EventDispatcher;

    import mx.collections.ArrayCollection;
    import mx.events.CollectionEvent;
    import mx.events.CollectionEventKind;
    import mx.events.PropertyChangeEvent;
    import mx.rpc.AsyncToken;
    import mx.rpc.Responder;
    import mx.rpc.events.FaultEvent;
    import mx.rpc.events.ResultEvent;
    import mx.rpc.remoting.mxml.RemoteObject;
    import mx.utils.ObjectUtil;

    [Event(name="result", type="mx.rpc.events.ResultEvent")]
    [Event(name="getItem", type="org.corlan.ItemEvent")]
    [Event(name="fault", type="mx.rpc.events.FaultEvent")]

    /**
     * This service wraps an RemoteObject to connect to the server.
     * Although it is created and tested with AMFPHP, it should work with no or minimum
     * changes with other server side technologies.
     * 
     * Imlements simplistic behaviour of Flex Data Services, in that this service can manage an
     * ArrayCollection items and save/read/delete items.
     * 
     * If you configured the VO like you would do for any remote object, then you will get an 
     * array collection of VOs.
     * 
     * You set the collection you want to be managed by calling the <code>fill()</code> method and
     * you save the changes by calling the <code>commit</code> method. When the fill method returns the result, 
     * an ResultEvent is dispatched.
     * 
     * You can retrieve one item by calling the <code>getItem</code> and sending the value you want
     * to be used as a filter.
     * 
     * No changes are committed until you call commit() method on the service.
     * When you call commit method, all the deleted items are committed, then the updated items 
     * and finally the inserts (in that order). The calls are queued.
     * 
     * You can call <code>revertChanges()</code> and all the uncommitted changes are reverted (delete/create/update).
     * So this call don't change anything on the server.
     * 
     * You need to register a listener for fault if you want to get error messages from 
     * the server.
     * 
     * On the server side, this component expects to find this methods implemented:
     *     - fill() - returns all the records from the table
     *  - getItem(condition) -  returns one item or none
     *  - saveItem(item) - saves one item (either insert or update)
     *  - saveCollection(collection) - saves an array of items (insert or update)
     *  - deleteItem(item) - delete an item
     *     - deleteCollection(collection) - deletes a collection of items
     */
    public class PHPDataService extends EventDispatcher {

        private var _collection:ArrayCollection;
        private var _revert:ArrayCollection = new ArrayCollection();

        private var _isChanged:Boolean = false;
        private var _isWriting:Boolean = false;

        private var _endpoint:String;
        private var _source:String;
        private var _destination:String;

        private var _remote:RemoteObject;

        private var _insert:ArrayCollection = new ArrayCollection();
        private var _update:ArrayCollection = new ArrayCollection();
        private var _delete:ArrayCollection = new ArrayCollection();

        public function fill(collection:ArrayCollection = null):void {
            if (collection != null) {
                _collection = collection;
                _collection.addEventListener(CollectionEvent.COLLECTION_CHANGE, onChangeCollection);
            }
            initializeRemote();

            var token:AsyncToken = _remote.fill();
            var responder:Responder = new Responder(onFill, onFault);
            token.addResponder(responder);
        }

        public function getItem(id:Object):void {
            initializeRemote();
            var token:AsyncToken = _remote.getItem(id);
            var responder:Responder = new Responder(onGetItemResult, onFault);
            token.addResponder(responder);
        }

        public function commit():void {
            if (!_isChanged)
                return;
            initializeRemote();
            var responder:Responder;
            var token:AsyncToken;
            if (_delete.length > 0) {
                token = _remote.deleteCollection(_delete);
                responder = new Responder(onDelete, onFault);
                token.addResponder(responder);
            } else if (_update.length > 0) {
                token = _remote.saveCollection(_update);
                responder = new Responder(onUpdate, onFault);
                token.addResponder(responder);
            } else if (_insert.length > 0) {
                token = _remote.saveCollection(_insert);
                responder = new Responder(onInsert, onFault);
                token.addResponder(responder);
            }
        }

        public function revertChanges():void {
            if (!_isChanged)
                return;
            if (_collection.length > 0)
                _collection.removeAll();
            for (var i:int = 0; i <_revert.length; i++) {
                _collection.addItem(_revert.getItemAt(i));
            }
        }

        private function initializeRemote():void {
            if (_remote != null)
                return;
            _remote = new RemoteObject(destination);
            _remote.source = source;
            _remote.endpoint = endpoint;
            _remote.showBusyCursor = true;
        }

        private function onDelete(event:ResultEvent):void {
            var responder:Responder;
            var token:AsyncToken;
            _delete.removeAll();
            if (_update.length > 0) {
                token = _remote.saveCollection(_update);
                responder = new Responder(onUpdate, onFault);
                token.addResponder(responder);
            } else if (_insert.length > 0) {
                token = _remote.saveCollection(_insert);
                responder = new Responder(onInsert, onFault);
                token.addResponder(responder);
            } else {
                _isChanged = false;
                fill();
            }
        }

        private function onUpdate(event:ResultEvent):void {
            _update.removeAll();
            if (_insert.length > 0) {
                var responder:Responder;
                var token:AsyncToken = _remote.saveCollection(_insert);
                responder = new Responder(onInsert, onFault);
                token.addResponder(responder);
            } else {
                _isChanged = false;
                fill();
            }
        }

        private function onInsert(event:ResultEvent):void {
            _insert.removeAll();
            _isChanged = false;
            fill();
        }

        private function onFill(event:ResultEvent):void {
            var arr:Array = event.result as Array;
            _isWriting = true;
            if (_collection.length > 0)
                _collection.removeAll();
            if (_revert.length > 0)
                _revert.removeAll();
            for (var i:int; i<arr.length; i++) {
                _collection.addItem(arr[i]);
                _revert.addItem(ObjectUtil.copy(arr[i]));
            }
            _isWriting = false;
            dispatchEvent(event);
        }

        private function onGetItemResult(event:ResultEvent):void {
            var ev:ItemEvent = new ItemEvent(ItemEvent.GET_ITEM, event.bubbles, event.cancelable, event.result, event.token, event.message);
            dispatchEvent(ev);
        }

        private function onFault(event:FaultEvent):void {
            trace(event.fault.faultString);
            dispatchEvent(event);
        }

        private function onChangeCollection(event:CollectionEvent):void {
            if (_isWriting)
                return;
            trace(event.kind);
            _isChanged = true;
            switch (event.kind) {
                case CollectionEventKind.ADD:
                    addFor(_insert, event.items, CollectionEventKind.ADD);
                    break;
                case CollectionEventKind.UPDATE:
                    addFor(_update, event.items, CollectionEventKind.UPDATE);
                    break;
                case CollectionEventKind.REMOVE:
                    addFor(_delete, event.items, CollectionEventKind.REMOVE);
                    break;
            }
        }

        private function addFor(collection:ArrayCollection, items:Array, eventType:String):void {
            for (var i:int; i<items.length; i++) {
                var obj:Object;
                if (items[i] is PropertyChangeEvent)
                    obj = (items[i] as PropertyChangeEvent).source;
                else
                    obj = items[i];

                if (collection.contains(obj))
                    return;

                switch (eventType) {
                    case CollectionEventKind.REMOVE:
                        //remove the item from update or insert
                        if (_insert.contains(obj)) {
                            _insert.removeItemAt(
                                    _insert.getItemIndex(obj));
                        } else if (_update.contains(obj)) {
                            _update.removeItemAt(
                                    _update.getItemIndex(obj));
                        }
                        collection.addItem(obj);
                        break;
                    case CollectionEventKind.UPDATE:
                        //if the item is already on insert, don' add
                        if (!_insert.contains(obj))
                            collection.addItem(obj);
                        break;
                    case CollectionEventKind.ADD:
                        collection.addItem(obj);
                        break;
                }
            }
        }

        public function set endpoint(value:String):void {
            _endpoint = value;
        }
        public function get endpoint():String {
            return _endpoint;
        }

        public function set source(value:String):void {
            _source = value;
        }
        public function get source():String {
            return _source;
        }

        public function set destination(value:String):void {
            _destination = value;
        }
        public function get destination():String {
            return _destination;
        }

    }
}

//connection info
define( "DATABASE_SERVER", "localhost");
define( "DATABASE_USERNAME", "mihai");
define( "DATABASE_PASSWORD", "mihai");
define( "DATABASE_NAME", "flex360");

abstract class BasePHPService {

    protected $_connection;
    private $_errorMessage;

    public function BasePHPService() {
        $this->_connection = mysql_connect(DATABASE_SERVER, DATABASE_USERNAME, DATABASE_PASSWORD);
        mysql_select_db(DATABASE_NAME);
    }

    protected function isError() {
        $message = mysql_error($this->_connection);
        if ($message != '') {
            $this->_errorMessage = mysql_errno($this->_connection) . ': ' . $message;
            return true;
        } else {
            $this->_errorMessage = '';
            return false;
        }
    }

    protected function getError() {
        return $this->_errorMessage;
    }

    /**
     * Escape the given value for SQL
     *
     * @param string $value
     * @return escaped value
     */
    protected function escapeForSql($value) {
        if (is_null($value) || $value === '') {
            $tmValue = '\'' . $value . '\'';
        } else {
            $tmValue = '\'' . str_replace(array("'", "\\"), array("''", "\\\\"), $value) . '\'';
        }

        return $tmValue;
    }

    abstract function fill(); 

    abstract function getItem($id);

    abstract function saveItem($item);

    abstract function saveCollection($collection);

    abstract function deleteItem($item);

    abstract function deleteCollection($collection);
}

<?php
class VOAuthor {

    public $id_aut;
    public $fname_aut;
    public $lname_aut;

    // explicit actionscript class
    var $_explicitType = "org.corlan.VOAuthor";
}
?>

require_once ('../BasePHPService.php');
require_once ('./vo/org/corlan/VOAuthor.php');

/**
* This class manages the table author_aut.
* It is intended to be used as RemoteObject with AMFPHP.
* To model the one row from the table, uses VOAuthor class.
* 
* When you want to throw an error up to the Flex calling code 
* (where you can catch with the listener registered for fault)
* you need to use: 
*     <code>throw new Error("error message to be displayed in Flex application");</code>
*/
class Author extends BasePHPService {

    public function Author() {
        parent::BasePHPService();
    }

    public function fill() {
        //retrieve all rows
        $query = 'SELECT id_aut, fname_aut, lname_aut FROM authors_aut ORDER BY fname_aut';
        $result = mysql_query($query, $this->_connection);
        if ($this->isError())
            throw new Exception($this->getError());
        $ret = array();
        while ($row = mysql_fetch_object($result)) {
            $tmp = new VOAuthor();
            $tmp->id_aut = $row->id_aut;
            $tmp->fname_aut = $row->fname_aut;
            $tmp->lname_aut = $row->lname_aut;
            $ret[] = $tmp;
        }
        mysql_free_result($result);
        return $ret;
    }

    public function getItem($id) {
        $query = 'SELECT id_aut, fname_aut, lname_aut FROM authors_aut WHERE id_aut = '. $this->escapeForSql($id);
        $result = mysql_query($query, $this->_connection);
        if ($this->isError())
            throw new Exception($this->getError());
        $ret = array();
        $row = mysql_fetch_object($result);
        $item = new VOAuthor();
        $item->id_aut = $row->id_aut;
        $item->fname_aut = $row->fname_aut;
        $item->lname_aut = $row->lname_aut;
        mysql_free_result($result);
        return $item;
    }

    public function saveItem($author) {
        if ($author == NULL)
            return NULL;
        if ($author->id_aut > 0) {
            $query = 'UPDATE authors_aut SET fname_aut='.$this->escapeForSql($author->fname_aut).', lname_aut='.$this->escapeForSql($author->lname_aut).' WHERE id_aut='.  $this->escapeForSql($author->id_aut);
        } else {
            $query = 'INSERT INTO authors_aut (fname_aut, lname_aut) VALUES ('.$this->escapeForSql($author->fname_aut).', '.$this->escapeForSql($author->lname_aut).')';
        }
        $result = mysql_query($query, $this->_connection);
        if ($this->isError())
            throw new Exception($this->getError());
        return NULL;
    }

    public function saveCollection($collection) {
        for ($i=0; $i<count($collection); $i++) {
            $this->saveItem($collection[$i]);
        }
    }

    public function deleteItem($author) {
        if ($author == NULL || !($author->id_aut > 0))
            return NULL;
        $query = 'DELETE FROM authors_aut WHERE id_aut = '. $this->escapeForSql($author->id_aut);
        mysql_query($query, $this->_connection);
        if ($this->isError())
            throw new Exception($this->getError());
    }

    public function deleteCollection($collection) {
        for ($i=0; $i<count($collection); $i++) {
            $this->deleteItem($collection[$i]);
        }
    }
}

//create the database and table
private function createDb():void {
    //create the database file in the application storage folder
    var file:File = File.applicationStorageDirectory.resolvePath("my.db");
    sqlConnectionSync = new SQLConnection();//create a connection object
    sqlConnectionSync.open(file, SQLMode.CREATE);//create the database
    if(file.exists)
        return;
    //create a statement
    var createDb:SQLStatement = new SQLStatement();
    //create a table
    createDb.text = "CREATE TABLE messages (id INTEGER PRIMARY KEY AUTOINCREMENT, subject VARCHAR(64), message VARCHAR(255))";
    createDb.sqlConnection = sqlConnectionSync; //set the connection that will be used
    createDb.execute();//execute the statement
}
//write the data
private function writeData():void {
    var insert:SQLStatement = new SQLStatement(); //create the insert statement
    insert.sqlConnection = sqlConnectionSync; //set the connection
    insert.text = "INSERT INTO messages (subject, message) VALUES (?, ?)";
    insert.parameters[0] = subject.text;
    insert.parameters[1] = message.text;
    insert.execute();
    Alert.show("The data was saved into the table!");
}
//read the data
private function readData():void {
    var read:SQLStatement = new SQLStatement(); //create the read statemen
    read.sqlConnection = sqlConnectionSync; //set the connection
    read.text = "SELECT id, subject, message FROM messages ORDER BY id";
    read.execute();
    var result:SQLResult = read.getResult(); //retrieve the result of the query
    myDatagrid.dataProvider = result.data; //display the array of objects into the data grid
}

//write an Object to a file
private function writeObject():void {
    var object:Object = new Object();//create an object to store
    object.value =  asObject.text; //set the text field value to the value property
    //create a file under the application storage folder
    var file:File = File.applicationStorageDirectory.resolvePath("myobject.file");
    if (file.exists)
        file.deleteFile();
    var fileStream:FileStream = new FileStream(); //create a file stream
    fileStream.open(file, FileMode.WRITE);// and open the file for write
    fileStream.writeObject(object);//write the object to the file
    fileStream.close();
}
//read an object stored into a file
private function readObject():void {
    //read the file
    var file:File = File.applicationStorageDirectory.resolvePath("myobject.file");
    if (!file.exists) {
        Alert.show("There is no object saved!");
        return;
    }
    //create a file stream and open it for reading
    var fileStream:FileStream = new FileStream();
    fileStream.open(file, FileMode.READ);
    var object:Object = fileStream.readObject(); //read the object
    Alert.show("The text member has this value: " + object.value);
}

<mx:Script>

/**
 * loader object used to load content from web
*/
private var loader:URLLoader = new URLLoader();

/**
 * This is the click handler for the button that save the web resource locally.
 * Just trigger the load and disable the button so no other 
 * request can be sent while it is already running one.
 */
private function saveResource():void {
    loader.load(new URLRequest(resURL.text));
    btn.enabled = false;
}

/**
 * This function gets called when the resource was loaded.
 * We just extract the name of the resource and call the saveLocally() function
 * to write the object on the local machine.
 */
private function onLoad(event:Event):void {
    btn.enabled = true; //enable the button so we can send another request.
    //get the file name of the resource
    var fileName:String = new String(resURL.text).split("/").pop();
    //call the saveLocally function; loader.data has the bytes of the loaded resource
    saveLocally(fileName, loader.data);
} 

/**
 * Error handler for loader object. 
 * I just display the error message and enable the button for new requests.
 */
private function onError(event:ErrorEvent):void {
    btn.enabled = true;
    Alert.show(event.text, "Error");
} 

/**
 * This function does the actual saving.
 * @param file name to be used for saving
 * @param bytes to be written
 */
private function saveLocally(fileName:String, data:ByteArray):void {
    //create a file under the application storage directory using the filename argument
    var file:File = File.applicationStorageDirectory.resolvePath(fileName);
    if (file.exists)
        file.deleteFile(); //delete it if exists
    //create a file stream to be able to write the content of the file    
    var fileStream:FileStream = new FileStream();
    //open the file stream and set for Write
    fileStream.open(file, FileMode.WRITE);
    //writes the bytes
    fileStream.writeBytes(data, 0, data.length);
    //close the stream
    fileStream.close();
    //display the path of the saved resources    
    showLocalPath.text = file.nativePath;
}

</mx:Script>

<mx:VBox left="10">    <mx:Label text="Store assets in files" fontSize="20"/>    <mx:Label text="Enter a resource URL such as http://mysite/image.jpg"/>    <mx:HBox>        <mx:TextInput id="resURL" text=""  width="600"/>        <mx:Button id="btn" click="saveResource()" label="Save locally" />    </mx:HBox>    <mx:Label id="showLocalPath" /></mx:VBox>

<mx:Script>
//store the text in the encrypted local store 
private function encrypt():void {
    var data:ByteArray = new ByteArray();
    data.writeUTFBytes(encryptText.text);//create a byte array out of the text we want to encrypt
    EncryptedLocalStore.setItem("myEncryptedData", data); //store the byte array into the encrypted local storage 
}
//read the data from the encrypted local store
private function decrypt():void {
    //using the same key I used when I wrote the data, I reead the bytes back
    var bytes:ByteArray = EncryptedLocalStore.getItem("myEncryptedData");
    if(bytes)
        Alert.show(bytes.readUTFBytes(bytes.bytesAvailable));
    else
        Alert.show("There was no value to be read!");
}
</mx:Script>
<mx:VBox left="10">
    <mx:Label text="Store ActionScript objects in the encrypted local store" fontSize="20"/>
    <mx:TextInput id="encryptText" />
    <mx:Button label="Encrypt" click="encrypt()" />
    <mx:Button label="Decrypt" click="decrypt()" />
</mx:VBox>