Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

Page 1   2  
sync4j.framework.client.* (9)sync4j.framework.config.* (2)sync4j.framework.core.* (93)
sync4j.framework.database.* (1)sync4j.framework.dm.* (13)sync4j.framework.engine.* (21)
sync4j.framework.logging.* (2)sync4j.framework.protocol.* (15)sync4j.framework.security.* (7)
sync4j.framework.server.* (65)

sync4j.framework: Javadoc index of package sync4j.framework.


Package Samples:

sync4j.framework.server.store: Base framework for building a data synchronization server  
sync4j.framework.client
sync4j.framework.config
sync4j.framework.core.xml.jdom
sync4j.framework.core.xml.nanoxml
sync4j.framework.core.xml
sync4j.framework.core
sync4j.framework.database
sync4j.framework.dm
sync4j.framework.engine.source
sync4j.framework.engine
sync4j.framework.logging
sync4j.framework.protocol.v11
sync4j.framework.protocol
sync4j.framework.security.jaas
sync4j.framework.security
sync4j.framework.server.error
sync4j.framework.server.session
sync4j.framework.server

Classes:

SyncStrategy: It defines the interface of a Synchronization Strategy object. It implements the Strategy partecipant of the Strategy Pattern. It is usually called by the synchronization engine when a syncronization action has to be performed. There are two types of synchronization process: slow and fast. Slow synchronization A slow synchronization is when the sources to be synchronized must be fully compared in order to reconstruct the right images of the data on both sources. The way the sets of items are compared is implementation specific and can vary from comparing just the key or the entire content of a ...
SyncPackage: This is a base abstract class for classes that implement SyncML protocol packages. A SyncML package is composed of a SyncHeader and a SyncBody which follows the requirements that the protocol mandates. SyncPackage and its subclasses are designed to be used in two steps. First a SyncPackage is created and checked for validity and compliancy with the protocol. Than getResponse() can be used to get a response message for the given request. During the request validation process some information about the request message are cached into instance variables and used in getResponse() . Subclasses are required ...
JAASOfficer: This implementation of Officier uses JAAS for authentication and authorization. In order to use this implementation, remember to set the system property java.security.auth.login.config accordingly as specified in JAAS documentation or in the documentation of the application server in use. For example, in the case of the J2EE RI, in order to use the SimpleLoginModule delivered with the framework, the following lines have to be added to the file {J2EESDK_HOME}/lib/security/login.config : sync4j { sync4j.framework.security.jaas.SimpleLoginModule required required debug=true; } The security policy ...
SyncEngine: A synchronization engine represents a mechanism used to drive the syncrhonization process. SyncEngine represents the Context partecipant of the Strategy pattern. It is a sort of factory and manager for the starategy object referenced by the property strategy (that implementing classes must provide). SyncEngine concentrate all the implementation specific information regarding strategies, sources, databases, services, etc. It is the point of contact between the synchronization, protocol and server services. When a synchronization process must take place, the SyncEngine will pass the control to the ...
PersistentStore: A PersistentStore is a class that stores objects in a persistent media such as a database. The work of saving and reading data to and from the store is delegated to the store() and read() methods that can take the appropriate actions based on the type of the object that has to be written or read. To store an object just call store(obj) . To read an object call read(obj). Note that those two methods return true if they know how to deal with the given object; that return value is not intended to be a success indicator. It just tells the caller that the PersistentStore knew how to process the given ...
SyncItem: SyncItem is the indivisible entity that can be exchanged in a synchronization process. It is similar to a sync4j.framework.core.Item , but this one is more generic, not related to any protocol. A SyncItem is uniquely identified by its SyncItemKey , whilst item data is stored in properties, which can be retrieved calling getProperty() , getProperties() and getPropertyValue() . Properties can be set by calling setProperties() , setProperty() and setPropertyValue() . A SyncItem is also associated with a state, which can be one of the values defined in SyncItemState . The following properties are considered ...
PersistentStoreManager: This class represents the main persistent store of the Sync4j server. It handles everything related to saving and reading information to and from the database, delegating the work to other PersistentStore s if necessary. PersistentStoreManager can be configured with a list of PersistetStore s that are called in sequence until one of them can process the given object. This list is expressed in the form of the string array stores ; each string is the name of a bean (or a class) and is loaded by sync4j.framework.tools.beans.BeanFramework .
LazyInitBean: This interface models beans that supports or requires lazy initialization. When a bean is created, first of all the empty constructor is created and the the bean properties are set. It the initialization of the bean meeds that the properties have a proper value a init() method may be provided so that the caller has an opportunity to separately initialize the bean before using it. The described mechanism is used in BeanFactory when an instance of the bean is created. If the bean implements LazyInitBean after creating the bean the method init() is called.
Node: This class corresponds to &ltNode&gt element of the SyncML Device Management Tree and Description Framework DTD. Node is the representation of an instantiated object. Note that this element is recursive and that a Node with a Value tag must always terminate the recursion. It is possible for a Node to omit both the next recursive Node and a Value, this means that the hierarchy of Nodes continues elsewhere. This can be used to increase readability of very deep trees.
Configuration: Incapsulates all the configuration information about a Sync4jEngine . Configuration parameters are stored as properties in a Map structure. The key is the name of the parameter and it is strucured in dotted separated namespaces. The value of the parameter is the value of the key and can be of any type. Accessor methods are provided to get the value of the parameter in a particular type (such as String, int, double, boolean, ...). Access to getXXX() and setXXX() methods are synchronized.
SyncItemImpl: SyncItem is the indivisible entity that can be exchanged in a synchronization process. It is similar to an Item, but it doesn't contain any data, only status and addressing information. The idea is that a SyncItem represents status information about an item. Only if an item must be synchronized it needs also the real data. The SyncItemKey uniquely identifies the item into the server. Client keys must be translated into server keys before create a SyncItem .
ClientModifications: Represents a Client Modification package of the SyncML protocol. The class is designed to be used in two times. First a ClientModification is created and checked for validity and compliancy with the protocol. Than getResponse() can be used to get a response message for the given request. During the request validation process some information about the request message are cached into instance variables and used in getResponse() . Example: TO DO
SyncInitialization: Represents the Initialization package of the SyncML protocol. Example: SyncInitialization syncInit = new SyncInitialization(header, body); ... do something ... syncInit.setServerCapabilities(serverCapabilities); syncInit.setAuthorizedStatusCode(StatusCode.AUTHENTICATION_ACCEPTED); syncInit.setClientCapabilitiesStatusCode(StatusCode.OK); ... other initializations ... Message response = syncInit.getResponse();
MD5Authentication: Implements the MD-5 authentication scheme. Since J2ME environment has limited memory space, instead of relying on the java.security library, we include only the necessary classes from bouncycastle . Since the changes are quite localized, so we skipped the hassle of creating an adapter for the bouncycastle library and the java.security library.
ClientCompletion: ClientCompletion class represent the phase or state that come after Modification phase. In this state client send status for the sync command, a status for every sub sync command like Add, Replace and finally send a MapCommand in the case a AddCommand was done succesfully. We need to extract this mapping information to update the LUID GUID Mapping. see the SyncML sync protocol for a detailed example
Sync4jLogger: Provides a common loggin facility for the framework. It is the mean the logging management can be centralized in a single class. The verbosity of the log can be set by the system property sync4j.log.level giving one of the following values (case insensitively): SEVERE WARNING INFO CONFIG FINE FINER FINEST ALL
Package: a SyncML package From syncml_represent_v101_20010615.pdf: "In SyncML, the data synchronization operations are conceptually bounded into a SyncML Package. The SyncML Package is just a conceptual frame for one or more SyncML Messages that are required to convey a set of data synchronization semantics. [...]"
SyncSource: A SyncSource is responsible for the storing and retrieving of SyncItem objects. It is used also for getting newly created or removed SyncItem s. Note that the SyncSource inteface doesn't make any assumption about the underlying data source. Each concrete implementation will use the storage its specific database.
UriNode: This class implements a node in a UriTree. The node keeps its sub tree in a Hashtable collection. The method createSubTree defines the instance The state of UriNode changes as it may have more/less children. The mutable data members in this class are synchronized for concurrent access.
ISO8601DateFormat: The SyncML element may contain an ISO8601 date or date/time stamp Ditto for and tag may contain an ISO 8601 date/time stamp tag may contain an ISO 8601 date/time stamp todo : possibly remove this class. Possibly replace with static methods: Util.iso8601ToDate Util.dateToIso8601
UriTree: This class implements a modifiable URI tree. UriTree is thread-safe; it is synchronized at root level. Most of the operations in this class goes through its own root node. Since the operations in the root node is synchronized, the client do not have to synchronize the instance of UriTree .
Occurrence: This class corresponds to &ltOccurrence&gt element of the SyncML DM Description Framework DTD. See p114 on "Item 21: Replace Enum Constructs with Classes" Content model: (One | ZeroOrOne | ZeroOrMore | OneOrMore | ZeroOrN | OneOrN )>
CredentialHandler: This handler implements the JAAS CallbackHandler interface. It stores a Credential object for later use as principal and credentials provider. This simple implementation supports basic authentication stored bas64 encoded in the form login:password. TO DO: supports MD5 authentication
Format: This class corresponds to &ltFormat&gt and &ltDFFormat&gt elements of the SyncML DM Description Framework DTD. See p114 on "Item 21: Replace Enum Constructs with Classes" Content model: (b64 | bool | chr | int | node | null | xml)>
CommandIdGenerator: This class creates command ids. Note that when a new CommandIdentifier is created, it is stored also in currentId , which is returned by current() . This is to avoid that current() creates a new CommandIdentifier object each time is called. This class is thread-safe.

Home | Contact Us | Privacy Policy | Terms of Service