1 /**

     2  * Copyright (c) 2010 Sasken Communication Technologies Ltd.

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of the "Eclipse Public License v1.0" 

     6  * which accompanies  this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html"

     8  *

     9  * Initial Contributors:

    10  * Chandradeep Gandhi, Sasken Communication Technologies Ltd - Initial contribution

    11  *

    12  * Contributors:

    13  * Manasij Roy, Nalina Hariharan

    14  * 

    15  * Description:

    16  * The Plugin Manager class manages the loading and unloading of plug-ins

    17  *

    18  */

    19 

    20 #ifndef SMFPLUGINMANAGER_H_

    21 #define SMFPLUGINMANAGER_H_

    22 

    23 #include <QtSql>

    24 #include <smfglobal.h>

    25 #include <smfserverglobal.h>

    26 #include "smfserver.h"

    27 

    28 // Forward declaration

    29 class SmfPluginManagerUtil;

    30 class SmfTransportManagerUtil;

    31 class QFileSystemWatcher;

    32 class QPluginLoader;

    33 class SmfPluginBase;

    34 class SmfProvider;

    35 

    36 /**

    37  * Structure that holds information about a plugin that is awaiting a 

    38  * response from Transport Manager

    39  */

    40 struct SmfWaitingPluginInfoStruc

    41 	{

    42 	/**

    43 	 * The server session ID for this request

    44 	 */

    45 	quint32 iSessionID;

    46 	/**

    47 	 * The plugin Id who creates this request

    48 	 */

    49 	QString iPluginId;

    50 	

    51 	/**

    52 	 * The instance of the loaded plugin

    53 	 */

    54 	SmfPluginBase *iInstance;

    55 	

    56 	/**

    57 	 * The type of operation requested by the plugin

    58 	 * @see smfglobal.h

    59 	 */

    60 	SmfRequestTypeID iOperation;

    61 	

    62 	/**

    63 	 * The input data for this request (if request need to be send again)

    64 	 */

    65 	QByteArray iInputData;

    66 	

    67 	/**

    68 	 * The list of valid Urls accessible for this plugin

    69 	 */

    70 	QList<QUrl> iUrlList;

    71 

    72 	};

    73 

    74 

    75 /**

    76  * The Plugin Manager class manages the loading and unloading of plug-ins

    77  */

    78 class SmfPluginManager : public QObject

    79 	{

    80 	Q_OBJECT

    81 	

    82 public:

    83 	/**

    84 	 * Method to get the instance of SmfPluginManager class

    85 	 * @param aServer The Smf server instance

    86 	 * @return The instance of SmfPluginManager class

    87 	 */

    88 	static SmfPluginManager* getInstance ( SmfServer *aServer = NULL );

    89 	

    90 	/**

    91 	 * Debugging only

    92 	 */

    93 	SmfServer* server ( ) { return m_server; }

    94 	

    95 	/**

    96 	 * Destructor

    97 	 */

    98 	~SmfPluginManager ( );

    99 	

   100 public:

   101 	/**

   102 	 * Method called by Smf server to create a web query.

   103 	 * Plugin Manager calls the appropriate web query creation method 

   104 	 * using the aOperation and aInputData parameters. Once the web request 

   105 	 * is ready, it calls the appropriate methods exposed by the Transport 

   106 	 * Manager to send the network request.

   107 	 * @param aSessionID The session ID provided by Smf Server

   108 	 * @param aPluginID The plugin ID that need to perform this operation

   109 	 * @param aOperation The type of operation to be performed

   110 	 * @param aInputData The data required to create the web query

   111 	 * @return SmfPluginManagerResult The result of the operation

   112 	 * @see smfglobal.h

   113 	 */

   114 	SmfPluginManagerResult createRequest ( const quint32& aSessionID, 

   115 			const QString& aPluginID, 

   116 			const SmfRequestTypeID& aOperation, 

   117 			QByteArray& aInputData );

   118 	

   119 	/**

   120 	 * Method called by Transport Manager when network response 

   121 	 * is available

   122 	 * @param aTransportResult The result of Transport Operation

   123 	 * @param aReply The QNetworkReply instance that requested 

   124 	 * this transaction

   125 	 * @param aResponse The network response data

   126 	 */

   127 	void responseAvailable ( const SmfTransportResult &aTransportResult, 

   128 			QNetworkReply *aReply,

   129 			QByteArray *aResponse );

   130 	

   131 	/**

   132 	 * Method to cancel the service request

   133 	 * @param aPluginId The plugin whose current operation 

   134 	 * is to be cancelled

   135 	 */

   136 	bool cancelRequest ( const QString& aPluginId );

   137 	

   138 	/**

   139 	 * Method to get the list of the SmfProvider for all the plugins that implement 

   140 	 * the mentioned Interface 

   141 	 * @param aInterface The interface for which list of plugins is required 

   142 	 * @param aMap The map of pluginID and its corresponding SmfProvider

   143 	 */

   144 	void getPlugins ( const QString& aInterface, 

   145 			QMap<QString,SmfProvider>& aMap );

   146 	

   147 	/**

   148 	 * Method to get the pluginID for the mentioned interface and service provider 

   149 	 * @param aInterface The interface implemented by the plugin

   150 	 * @param aProv The plugin's service provider

   151 	 * @param aPluginId The required pluginID

   152 	 */

   153 	void getPluginId ( const QString& aInterface, 

   154 			const SmfProvider& aProv, QString& aPluginId );

   155 	

   156 private:

   157 	/**

   158 	 * Method called to initialize the file watcher watching the file  

   159 	 * system for adition/upgradation/removal of plugins

   160 	 */

   161 	void initializeFileWatcher ( );

   162 	

   163 	/**

   164 	 * Method called to initialize the database holding the plugin 

   165 	 * directory sructure information. This is called only once when 

   166 	 * the Plugin Manager is instantiated.

   167 	 * This method creates and updates iPluginIdPathHash member 

   168 	 * of this class

   169 	 * @return Retuns true if success else false

   170 	 */

   171 	bool initializeSmfPluginDataBase ( );

   172 	

   173 	/**

   174 	 * Method to load a plugin using its Plugin Id.

   175 	 * @param aPluginId The unique ID of the plugin 

   176 	 * @param aLoadResult [out] Output paramater indicating the result 

   177 	 * of the loading

   178 	 * @return The instance of the loaded plugin if loaded, else NULL

   179 	 */

   180 	QObject* load ( const QString &aPluginId, 

   181 			SmfPluginManagerResult &aLoadResult);

   182 	

   183 	/**

   184 	 * Method to unload a loaded plugin. Returns true if success, else 

   185 	 * returns false.

   186 	 * @param aPlugin The plugin instance to be unloaded

   187 	 * @return Returns true if success, else returns false

   188 	 */

   189 	bool unload ( SmfPluginBase *aPlugin ); 

   190 	

   191 	/**

   192 	 * Method to unload the list of loaded plugins. Returns true if all are 

   193 	 * success, else returns false if any one fails.

   194 	 * @param aPluginList The list of instances for all plugins that are 

   195 	 * to be unloaded

   196 	 * @return Returns true if all are success, else returns false if any 

   197 	 * one fails.

   198 	 */

   199 	bool unload ( const QList<SmfPluginBase*> &aPluginList);

   200 	

   201 	/**

   202 	 * Method that calls the Transport Manager Utility class method to 

   203 	 * send the request created by the plugins over the network

   204 	 * @param aReqData The request data created by the plugin

   205 	 * @param aResult [out] The output parameter indicating the result 

   206 	 * of this method

   207 	 * @param aUrlList The list of accessible Urls for this plugin

   208 	 * @see smfglobal.h

   209 	 */

   210 	void sendRequest ( SmfPluginRequestData &aReqData, 

   211 			SmfPluginManagerResult &aResult,

   212 			const QList<QUrl> &aUrlList );

   213 	

   214 	/**

   215 	 * Method that checks if a plugin is authorised to make a request. 

   216 	 * This method communicates with Credential and Settings Manager 

   217 	 * through Smf server, giving the registration token and getting 

   218 	 * the valid url list if available for this plugin.

   219 	 * @param aRegToken The registration token given by the plugin

   220 	 * @param aUrlList [out] The list of Urls that the plugin can send 

   221 	 * request to (to be filled by CSM)

   222 	 * @return Returns true if plugin is authorised, else returns false.

   223 	 */

   224 	bool authorisePlugin( const QString &aRegToken, 

   225 			QList<QUrl> &aUrlList );

   226 	

   227 	/**

   228 	 * Method to serialize the result of parsing (which is done by the 

   229 	 * plugins) to QByteArray to be sent to Smf server.

   230 	 * @param aOperation The type of operation to be performed

   231 	 * @param aResult The data to be serialized

   232 	 * @param aDataStream Stream to be written

   233 	 */

   234 	void serializeResult ( const SmfRequestTypeID &aOperation, 

   235 			QVariant* aResult,

   236 			QDataStream &aDataStream );

   237 	

   238 private slots:

   239 	/**

   240 	 * Method for the directoryChanged signal of QFileSystemWatcher.

   241 	 * This will update the iPluginHash member and also the Plugin 

   242 	 * Information List.

   243 	 * @param aPath The path of the directory that has changed

   244 	 */

   245 	void directoryChanged ( const QString &aPath );

   246 

   247 private:

   248 	/**

   249 	 * Constructor with default argument

   250 	 * @param aServer The Smf server instance

   251 	 */

   252 	SmfPluginManager ( SmfServer *aServer );

   253 	

   254 	/**

   255 	 * Copy Constructor

   256 	 * @param aOther The reference object

   257 	 */

   258 	SmfPluginManager ( const SmfPluginManager &aOther );

   259 	

   260 private:

   261 	/**

   262 	 * The single instance of SmfPluginManager

   263 	 */

   264 	static SmfPluginManager* m_myInstance;

   265 	

   266 	/**

   267 	 * Member variable that maps the plugin instances to their 

   268 	 * respective QPluginLoader instances (loaders may be multiple)

   269 	 */

   270 	QHash<SmfPluginBase*, QPluginLoader*> m_pluginLoaderHash;

   271 	

   272 	/**

   273 	 * Member variable that watches the file system for 

   274 	 * addition/upgradation/removal of plugins 

   275 	 */

   276 	QFileSystemWatcher *m_fileWatcher;

   277 	

   278 	/**

   279 	 * Member variable that is an instance of a structure that 

   280 	 * holds a loaded plugin information 

   281 	 */

   282 	SmfWaitingPluginInfoStruc *m_tempStruct;

   283 	

   284 	/**

   285 	 * Member variable that maps a QNetworkReply instance to 

   286 	 * its corresponding loaded plugin information structure  

   287 	 */

   288 	QHash<QNetworkReply*, SmfWaitingPluginInfoStruc*> m_waitingPluginHash;

   289 	

   290 	/**

   291 	 * Member variable that maps a pluginId to its path

   292 	 */

   293 	QHash<QString, QString> m_pluginIdPathHash;

   294 	

   295 	/**

   296 	 * Member variable that holds the instance of 

   297 	 * SmfServer class

   298 	 */

   299 	SmfServer *m_server;

   300 	

   301 	/**

   302 	 * Member variable that holds the instance of 

   303 	 * SmfTransportManagerUtil class

   304 	 */

   305 	SmfTransportManagerUtil *m_transMngrUtil;

   306 

   307 	/**

   308 	 * Member variable that holds the instance of 

   309 	 * SmfPluginManagerUtil class. SmfPluginManager is a friend of SmfPluginManagerUtil.

   310 	 */

   311 	SmfPluginManagerUtil *m_util;

   312 

   313 	/**

   314 	 * Member variable that holds QSqlDatabase instance.

   315 	 */

   316 	QSqlDatabase m_pluginDataBase;

   317 	

   318 	};

   319 

   320 #endif /* SMFPLUGINMANAGER_H_ */