Indicates if changes to the local cache are automatically committed. Committed changes are sent to the remote service immediately.

The default value is true.

Indicates if this service should attempt to connect for any operations that require a connection. Operations like fill(), getItem() and count() will attempt to connect if the service is disconnected and autoConnect is set to true. Use this property to control occasionally connected application behavior.

The default value is true.

If set to false, when changes are pushed from the remote destination to the client they are not immediately applied. Instead, the mergeRequired property is set to true. An event handler can be registered to listen for change events on this property to be notified of when a merge needs to be applied. To merge changes, call the merge() method and all changes are applied. Uncommited changes can not be committed when there are any changes that need to be merged. If paging is enabled all requests for non local items are cached until merge() is called. Once merge() is called, the cached requests are processed.

The default value is true.

The local cache of data and changes can be stored to disk. When autoSaveCache is true each time a change is made or a remote request is returned, that data will be saved to disk. If there is a problem saving the data either because the disk is full or write permissions have been denied a FaultEvent will be dispatched or a Fault will be thrown. Setting this value to false (the default) will not save any data or changes to disk. To force the current data and changes to be saved to disk use the saveCache method.

The default value is false.

Provides access to the cache identifier for this service. A cache identifier must be set prior to performing any operations that require interaction with data stored locally on disk. If a cache identifier is not set, all cache methods and properties are considered inconsistent and a DataServiceError is thrown during any operation that requires data from the local disk. This property provides a unique "session" identifier for data stored locally. A developer must set this property to a unique value for the application. A value of null or empty string is considered unset. Requests for data by methods like fill() and getItem() will attempt to access the local data on disk first if the cacheID has been set. If the cacheID is not set, no attempt to access any local data will be made.

Indicates if there are changes that have not been committed and the commit() method should be called. When this property changes, an event is dispatched. This property can be used within an application to provide visual feedback.

This property can be used as the source for data binding.

Provides access to the current implementation being used to detect conflicts for remote operations pushed to this DataService.

Returns the Conflicts object, an ArrayList of Conflict instances. Conflicts must be resolved before commit() can be called. Conflicts can be resolved by going through the conflicts, resolving each conflict individually or by calling the acceptAllClient() method or acceptAllServer() method on this property.

Returns an object of type mx.data.DataStore. The DataStore manages the set of incoming and outgoing changes for one or more DataServices, which may have references between them. When you commit on a DataStore, all of the pending changes of each DataService using that DataStore are committed. By default, a DataService shares the same DataStore with other DataServices if they have managed association properties and share the same set of channels. If you are sharing DataStores, a commit call on one DataService commits changes for all DataServices using that data store. This preserves the order of operations in case there are dependencies between the changes in your uncommitted batches.

This property can be used as the source for data binding.

Indicates which remote destination this service is associated with.

To tune the speed of your application, set this to false if you have a small number of fills or references to items managed by this data service from association properties of other items.

Indicates if there are any pending changes that must be merged.

This property can be used as the source for data binding.

Provides access to the current page size setting for all collections.

Indicates if the remote destination is configured to allow paged requests.

Provides access to the request timeout in seconds for an operation. A value less than or equal to zero prevents request timeout. When a current operation times out due to the requestTimeout limit being reached a fault will be dispatched for that operation, indicating that the request was timed out. Note that when an operation times out, it is possible the server did in fact receive that operation. This can leave your client state out of sync with the server.

Constructs an instance of the DataService with the specified destination. The destination must be a reference to a destination configured in the services-config.xml file.

Registers an event listener object with an EventDispatcher object so that the listener receives notification of an event. You can register event listeners on all nodes in the display list for a specific type of event, phase, and priority.

JavaScript code in the AIR runtime uses this method to register event listeners for events defined by the AIR APIs. For other JavaScript events (such as the onload event of the DOM body object), you can use standard event handling techniques, as you would for content running in the browser.

After you successfully register an event listener, you cannot change its priority through additional calls to addEventListener(). To change a listener's priority, you must first call removeListener(). Then you can register the listener again with the new priority level.

Keep in mind that after the listener is registered, subsequent calls to addEventListener() with a different type or useCapture value result in the creation of a separate listener registration. For example, if you first register a listener with useCapture set to true, it listens only during the capture phase. If you call addEventListener() again using the same listener object, but with useCapture set to false, you have two separate listeners: one that listens during the capture phase and another that listens during the target and bubbling phases.

You cannot register an event listener for only the target phase or the bubbling phase. Those phases are coupled during registration because bubbling applies only to the ancestors of the target node.

If you no longer need an event listener, remove it by calling removeEventListener(), or memory problems could result. Objects with registered event listeners are not automatically removed from memory because the garbage collector does not remove objects that still have references.

Copying an EventDispatcher instance does not copy the event listeners attached to it. (If your newly created node needs an event listener, you must attach the listener after creating the node.) However, if you move an EventDispatcher instance, the event listeners attached to it move along with it.

If the event listener is being registered on a node while an event is being processed on this node, the event listener is not triggered during the current phase but can be triggered during a later phase in the event flow, such as the bubbling phase.

If an event listener is removed from a node while an event is being processed on the node, it is still triggered by the current actions. After it is removed, the event listener is never invoked again (unless registered again for future processing).

Parameters

function(evt:Event):void

Clears any data stored to disk with a previous call to saveCache() or when autoSaveCache was set to true

Parameters

Clears the data specified by the passed descriptor from the local store.

Parameters

Commits pending changes for all collections currently managed by the DataStore associated with this data service. Calling this method is equivalent to calling dataStore.commit().

When the autoCommit property is true, transactions are not used and you do not need to call this method. To use transactions, set the autoCommit property to false and call this method directly to commit a batch of changes.

You typically just call "commit()" with no arguments which will commit all pending changes. You can supply optional arguments to commit a subset of the pending changes. You must resolve all outstanding conflicts before you can commit changes to any item in the DataStore.

If the assembler is configured to have use-transactions set to true, all changes are committed atomically. If any operation fails, none of the operations in the batch are applied. If use-transactions is set to false, the operations are each committed individually until a failure occurs at which point processing stops. Any changes that occur before the error are applied, any changes which occur after the error are not applied. When an error occurs when processing a batch, the changes are put back into the uncommitted queue. You need to call revertChanges if you want to remove the changes which caused the error.

By default, the commit method will commit all pending changes for all items which have been created, modified, and deleted for this DataStore. If you want to commit a subset of these changes, you can specify a combination of managed ArrayCollection instances and/or managed items which define the subset of changes you want included in the batch. For each array collection you specify, any changes made either to the membership or order of items in that that array collection or any changes to items in that array collection are committed. You can also specify a list of individual managed items so that only changes for those items are committed. If you specify any objects in the itemsOrCollections parameter which are not managed collections or items, a DataServiceError is thrown.

If you are using the itemsOrCollections parameter and your items have association properties which refer to other items, you can use the cascadeCommit parameter to control whether or not changes made to associated items are also included in batch. For example, if you specify a Group item in the items parameter, and the Group instance has a members property which refers to a list of Person instances when cascadeCommit is true changes to any Person instance will also be included in the set of changes committed. If cascadeCommit is false, only changes to the Group would be included. Use cascadeCommit=true to ensure that any dependent changes are included in the batch.

Parameters

Forces a connection attempt by this service to the remote destination. This method may be used in conjunction with the autoConnect property and disconnect() method to control connection status.

Calls a count method on the remote destination. The count method called is based on the associated <count-method> tags and the parameters passed. For example, if the following count("firstName", "Bob") call was made and <count-method> tags exist or are referenced in the services-config.xml under the associated destination:

 
            <count-method>
                <name>getCount</name>
                <params>java.lang.String,java.lang.String</params>
                <security-run-as name="freddie" password="nightmare" />
            </count-method>
            
            <count-method>
                <name>getCount</name>
                <security-constraint ref="sample-users" />
            </count-method>
      

Parameters

Requests that the specified item be created in the remote store. If an error occurs a DataConflictEvent is dispatched.

Parameters

Requests that the specified item be deleted from the remote store. If an error occurs a DataConflictEvent will be dispatched.

Parameters

Disconnects the DataService's network connection. This method does not wait for outstanding network operations to complete.

Fills the specified ListCollectionView based on the associated <fill-method> elements. For example, if the following <fill-method> elements exist or are referenced in the services-config.xml under the associated destination:

            <fill-method>
                <name>loadPersons</name>
                <params>java.lang.String,java.lang.String</params>
                <security-run-as name="freddie" password="nightmare" />
            </fill-method>
            
            <fill-method>
                <name>loadPersons</name>
                <security-constraint ref="sample-users" />
            </fill-method>
      

Parameters

Returns an ArrayCollection or a single managed object (SMO) from the the local store. Calling this method will not update the last accessed time.

Parameters

This method will fill the specified ListCollectionView with CacheDataDescriptor(s). If no argument is specified then all associated CacheDataDescriptors for cached data under this service will be returned.

Parameters

This method will fill the specified ListCollectionView with all cache identifiers previously used in the application.

Parameters

Makes an asynchronous request for an item matching the specified identity. If you provide a defaultValue, and the item does not exist, the item is created instead using the information in the defaultValue. This method returns an ItemReference. If you receive a valid instance from the getItem() method call, you must call the releaseItem() method to release an instance of the item. If you hang onto the ItemReference, you should call the releaseItem() method on the reference to be sure you release the proper reference (in case your client has made more than one getItem() method call for the same item). If you do not hold onto the ItemReference, you can call the releaseItem() method on the DataService with the item itself.

Parameters

Returns the pending operation in the message cache for the specified item. Use this method to provide visual feedback to a user of what type of change, if any, has been made to an item.

Parameters

Logs the user out of the destination for the DataService. Logging out of a destination applies to everything connected using the same ChannelSet as specified in the server configuration. For example, if you are connected over the my-rtmp channel and you log out using one of your DataService instances, anything that was connected over the same ChannelSet is logged out.

Merges any pending updates into the managed set of objects. The process of merging changes detect conflicts and process any pending item requests. This merges all messages for any other DataService instances that share this same data store.

Releases all managed collections and items for the DataService.

Parameters

Releases any item within the specified collection from management by this service. If the item exists in more than one collection, a copy of the item is made. Any uncommitted changes made to an item that exists only in this collection are released, including deletes, creates and updates.

Parameters

Releases the specified item from management by this service. If you hold onto ItemReferences, you should call the releaseItem() method on the ItemReference to be sure you release the proper reference in the case where you might have made more than one getItem call which retrieves the same item from different parts of your client application.

This call releases any associated resources, including nested properties. The specified item no longer receives updates from the remote destination. In addition if there are any uncommited changes to this item and it does not appear in any other collection these changes will also be released. If the specified item exists in more than one collection then the value handed back will be a copy of the original unless the allowCopy parameter is set to false.

Parameters

Reverts any uncommitted changes to the specified item. Or if no item is supplied, it will revert all uncommitted changes. If you revert a create operation, it removes the item. If you revert a delete, it adds the item back in. Reverting an update restores the original properties of the item that were in place before you started changing it. Calling this method is equivalent to calling dataStore.revertChanges().

One situation in which you would use this method is after a fault has occurred. In that case, any failed changes are put back into the uncommitted changes list. At that point you can either modify those changes to fix the problem or revert them using this method to keep those changes from being resubmitted again.

If an item is supplied and this item doesn't have any changes this method will return false. If no item is supplied and there are no changes this method returns false. Otherwise, it returns true.

Parameters

This method will save the current state of the DataService cache. The cache includes in-memory items and changes made to those items that have not been sent to the remote destination.

Parameters

Sets the credentials for this DataService destination. The credentials are applied to all services connected over the same ChannelSet.

Parameters

Sets the credentials for the third party of this DataService destination.

Parameters