ButeoSynchronizationFramework
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
 NButeo
 CAccountsHelperHelper Class towards Accounts::Manager and various SSO related operations
 CClientPluginBase class for client plugins
 CClientPluginRunnerClass for running client sync plug-ins
 CClientThreadThread for client plugins
 CDatabaseResults
 CDeletedItemsIdStoragePersistent storage for storing deleted item IDs
 CIPHeartBeatIPHeartBeat implementation
 CItemCountsContainer for number of items added, deleted and modified
 CLoggerA logger singleton class
 CLogTimerHelper class for timing function execution time
 CNetworkManagerClass for managing network sessions
 COOPClientPlugin
 COOPServerPlugin
 CPluginCbImpl
 CPluginCbInterfaceInterface which client and server plugins can use to communicate with synchronization daemon
 CPluginManagerManages plugins
 CPluginRunnerBase class for running sync plug-ins
 CProfileThis class represents a single profile, a collection of settings or data releated to some entity
 CProfileFactoryProfileFactory handles creating Profile instances
 CProfileFieldThis class represents a profile field
 CProfileManagerProfileManager is responsible for storing and retrieving the profiles
 CSearchCriteriaSearch criteria for finding profiles
 CProfilePrivatePrivate implementation class for Profile class
 CServerActivatorKeeps track of which server plug-ins should be enabled
 CServerPluginBase class for server plugins
 CServerPluginRunnerClass for running server sync plug-ins
 CServerThreadThread for server plugin
 CStorageBookerA helper class for managing storage reservations
 CStorageChangeNotifierNotifies about changes in storages that it's asked to monitor
 CStorageChangeNotifierPluginImplement this class to notify about changes in a specific storage - contacts/calendar/sms, or even custom ones like a facebook storage, if there's such a storage on the device
 CStorageItemClass to describe a storable item
 CStoragePluginBase class for storage plugins
 CStorageProfileStorage Profile Class
 CSyncBackupHandles Sync requirements towards Backup
 CSyncBackupAdaptorAdaptor class for interface com.nokia.backupclient
 CSyncBackupProxyDefines a D-Bus backup proxy for the backupclient
 CSyncClientInterfaceSyncInterface Class - Main Entry Point for SyncFW Clients
 CSyncClientInterfacePrivatePrivate implementation class for SyncClientInterface
 CSyncDBusInterfaceDefines a D-Bus interface for the sync daemon
 CSynchronizerThe main entry point to the synchronization framework
 CSyncLogHistory of completed synchronization sessions and their results
 CSyncOnChangeThis class initiates a sync if there are changes in storage(s) it's asked to monitor
 CSyncOnChangeScheduler
 CSyncOnChangeTimer
 CSyncPluginBaseBase class for client and server plugins
 CReceivedItemDetails
 CSyncProfileA top level synchronization profile
 CSyncQueueClass for queuing sync sessions
 CSyncResultsContains information about a completed synchronization session
 CSyncScheduleClass for handling sync schedule settings
 CSyncSchedulePrivatePrivate implementation class for SyncSchedule
 CSyncSchedulerSyncScheduler Object to be used to set Schedule via the framework
 CSyncSessionClass representing a single sync session
 CTargetResultsSync results for one target
 CTransportTrackerClass for tracking transport states
 CUSBModedProxy
  • Proxy class for interface com.meego.usb_moded
 CBackgroundSyncBackgroundSync implementation
 CBTStrings used for DBus communication with bluetooth daemon are grouped using this structure
 CBtHelperImplementation for bluetooth helper utils
 CButeoPluginIface
 CButeoPluginIfaceAdaptor
 CPluginServiceObj
 CQList
 CQMap
 CSyncAlarmInventoryClass for storing alarms
 CSyncDaemonProxyProxy class for interface com.meego.msyncd
 CSyncDBusAdaptor
 CSyncSigHandlerAbout this class. We can't call Qt functions from Unix signal handlers.We can only call async-signal-safe functions from signal handlers. So this provides a way to use Unix signal handlers with Qt. The strategy is to have our Unix signal handler will eventually cause a Qt signal to be emitted, and then we simply return from our Unix signal handler. Back in our Qt program, that Qt signal gets emitted and then received by our Qt slot function, where we are safely doing Qt stuff which weren't allowed to do in the Unix signal handler. One simple way to make this happen is declares a socket pair in our class for each Unix signal we want to handle. The socket pairs are declared as static data members.We also created a QSocketNotifier to monitor the read end of each socket pair, declare your Unix signal handlers to be static class methods, and declare a slot function corresponding to each of our Unix signal handlers. In this class, we intend to handle both the SIGHUP and SIGTERM signals