--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/smf/smfservermodule/smfserver/server/smfserver.cpp	Tue May 18 17:37:12 2010 +0530
@@ -0,0 +1,385 @@
+/**
+ * Copyright (c) 2010 Sasken Communication Technologies Ltd.
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of the "Eclipse Public License v1.0" 
+ * which accompanies  this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html"
+ *
+ * Initial Contributors:
+ * Chandradeep Gandhi, Sasken Communication Technologies Ltd - Initial contribution
+ *
+ * Contributors:
+ * Manasij Roy, Nalina Hariharan
+ */
+
+#include "smfserver.h"
+#include "smfpluginmanager.h"
+#include "smftransportmanager.h"
+#include "smfclientglobal.h"
+#include <smfprovider.h>
+#include <smfpost.h>
+#include <smflocation.h>
+#include <smfcontact.h>
+#include <smfpicture.h>
+#include <smfcomment.h>
+//#ifdef NO_OTHER_MODULES
+#include <QImage>
+#include <QUrl>
+#include <smfgroup.h>
+#include <QTextStream>
+#include <QFile>
+//#endif
+#ifdef Q_OS_SYMBIAN
+#include "smfserversymbian_p.h"
+#else
+#include "smfserverqt_p.h"
+#endif
+
+SmfServer::SmfServer(QObject* parent): QObject(parent)
+	{
+	}
+bool SmfServer::startServer()
+	{
+	bool success = false;
+	//Initialize all the component handles
+	writeLog("Not doing SmfTransportManager::getInstance");
+	//m_transportManager = SmfTransportManager::getInstance();
+	writeLog("Not doing m_transportManager->initializeTransport");
+	//checking the network status, no need to proceed if not permitted
+	//SmfTransportInitializeResult networkStatus = m_transportManager->initializeTransport();
+	writeLog("Before networkStatus");
+	//TODO:-check this
+	if(1/*networkStatus == SmfTransportInitNoError*/)
+		{
+		writeLog("Before m_pluginManager construction");
+		m_pluginManager = SmfPluginManager::getInstance(this);
+		writeLog("After m_pluginManager construction");
+		//	m_dataStoreManager = new SmfDataStoreManager();
+		//Initialize private implementation
+		#ifdef Q_OS_SYMBIAN
+		TRAPD(err, m_SmfServerPrivate = SmfServerSymbian::NewL(CActive::EPriorityStandard,this));
+		QString log("SmfServer::startServer=");
+		int errorQ = err ;
+		log += errorQ;
+		 writeLog(log);
+		if( KErrNone != err )
+			{
+			return success;
+			}
+		TInt error = m_SmfServerPrivate->Start( KSmfServerName );
+		errorQ = error ;
+		log.clear();
+		log = QString("m_SmfServerPrivate->Start=");
+		log += QString::number(error);
+		 writeLog(log);
+		if( KErrNone == error ) 
+			{
+			success = true;
+			}
+		else 
+			{
+			//error
+			return success;
+			}
+		#else
+		m_SmfServerPrivate = new SmfServerQt();
+		success = m_SmfServerPrivate->start();
+		if (!success) 
+			{
+			return success;
+			}
+		#endif
+		//request CM server for auth expiry info, note:- we should resend the request everytime we get expiry
+		//notification
+		//TODO:- Do it after CM implementation
+		//CMclient->requestAuthExpiryNotify();
+		//connect(CMClient,SIGNAL(authExpiryNotify(NotificationType,SmfPluginID),this,SLOT(NotificationType,SmfPluginID));
+		}
+    return success;
+	}
+//Note:- Almost all the following APIs are called by private impl via the handle
+/**
+ * This called first once a session is created by the private impl
+ * @param clientID some unique client process ID, SID for symbian platform
+ * TODO:-How to get the pid for rest of the platforms?
+ * @return true if client is already athorized, else false
+ * 
+ */
+bool SmfServer::isClientAuthorized(SmfClientAuthID clientID)
+	{
+	//TODO:- once CM is complete do it properly
+	Q_UNUSED(clientID);
+	return true;
+	}
+/**
+ * This API is called by the private impl when isClientAuthorized returns false
+ * @param clientID client Id (SID for symbian platform), provided by the private impl
+ * Note:- The session(and in turn the client) will be blocked untill authorization completes.
+ */
+void SmfServer::authorizeClient(SmfClientAuthID clientID)
+	{
+	//TODO:- once CM is complete, do it properly
+	//CMclient->authorizeClient(clientID)
+	//connect(CMClient,SIGNAL(clientAuthorizationFinished(bool,SmfClientAuthID)),this,SLOT(clientAuthorizationFinished(bool,SmfClientAuthID)));
+	Q_UNUSED(clientID);	
+	}
+/**
+ * This API is called by the private impl when client is authorized
+ * @param interfaceID Interface id, provided by the private impl (it gets it from client)
+ * @param pluginIDMap Map of plugins who implement this interface and corresponding provider,
+ * this is returned to the private impl
+ * It calls PM to get the list. Note:- PM may return SmfProviderBase which is superset of SmfProvider.
+ * TODO:- session should store this map for future ref?
+ */
+void SmfServer::getPlugins(SmfInterfaceID interfaceID, QMap<SmfPluginID,SmfProvider>& pluginIDMap)
+	{
+	pluginIDMap.clear();
+	m_pluginManager->getPlugins(interfaceID,pluginIDMap);
+	}
+
+SmfPluginID SmfServer::getPlugin(SmfInterfaceID interfaceID,SmfProvider provider)
+	{
+	//TODO:- do it properly as per PM implementation
+	//return PM->getplugin(interfaceID,provider);
+	//TODO:- PM is not yet ready
+	SmfPluginID id;
+	m_pluginManager->getPluginId(interfaceID,provider, id);
+	return id;
+	//testing purpose only
+	}
+/**
+ * This API is called by the private impl to get a list of authorized plugins from CM
+ * @param list List of plugins to be filtered
+ * @param authList List of authorised plugins filled by CM
+ * this is returned to the private impl
+ * It calls CMclient to get the list synchronously
+ * TODO:- session should store this for future ref?
+ */
+void SmfServer::getAuthorizedPlugins(QList<SmfPluginID>& list,QList<SmfPluginID>& authList)
+	{
+	//TODO:- do it properly as per CMclient implementation
+	//CMclient->getAuthorizedPlugins(list,authList);
+	//testing purpose only
+#ifdef NO_OTHER_MODULES
+	authList = list;
+#endif
+	}
+/**
+ * This API is called by the private impl to request the PM to do the actual request/parsing asynchronously
+ * Note:- the sever private impl (SmfServerSymbian for symbian platform) maintains a map of session ptr and some randomely
+ * generated number.For the time being we are allowing only one outstanding request per session, so no need to store
+ * both session and msg ptr, but in future we may need to.
+ * @param requestID Request id (corresponds to the key of the mapmaintained by SmfServerSymbian).
+ * @param pluginID PluginID, provided by the session
+ * @param interfaceID InterfaceID provided by session
+ * @requestTypeID Request Opcode, provided by session
+ */
+void SmfServer::getRequestedData(int requestID,SmfPluginID pluginID,SmfInterfaceID interfaceID, SmfRequestTypeID requestTypeID,QByteArray dataForPlugin)
+	{
+		//TODO:- cross check the params with PM owner
+		//PM->getData(requestID,pluginID,interfaceID,requestTypeID);
+		m_SmfServerPrivate->writeLog("SmfServer::getRequestedData");
+		m_SmfServerPrivate->writeLog(QString::number(requestID));
+		m_SmfServerPrivate->writeLog(pluginID);
+		m_SmfServerPrivate->writeLog(interfaceID);
+		m_SmfServerPrivate->writeLog(QString::number(requestTypeID));
+		bool defaultCase = false;
+		//serializedInfo contains base provider info+ other data depending on requestTypeID
+		QDataStream reader(&dataForPlugin,QIODevice::ReadOnly);
+		QByteArray dataTobeSent;
+		switch(requestTypeID)
+			{
+			case SmfContactPost:
+				{
+				SmfProvider provider;
+				SmfPost post;
+				SmfLocation loc;
+				reader>>provider;
+				reader>>post;
+				reader>>loc;
+				//now form the serialized bytearray with only SmfPost and SmfPlace
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<post;
+				writer<<loc;
+				}
+				break;
+			case SmfContactUpdatePost:
+				{
+				SmfProvider provider;
+				SmfPost post;
+				reader>>provider;
+				reader>>post;
+				//now form the serialized bytearray with only SmfPost
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<post;
+				}
+				break;
+			case SmfContactPostDirected:
+				{
+				SmfProvider provider;
+				SmfPost post;
+				SmfContact contact;
+				SmfLocation place;
+				reader>>provider;
+				reader>>post;
+				reader>>contact;
+				reader>>place;
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<post;
+				writer<<contact;
+				writer<<place;
+				}
+				break;
+			case SmfContactSharePost:
+				{
+				SmfProvider provider;
+				SmfPost post;
+				SmfContact contact;
+				bool edited;
+				reader>>provider;
+				reader>>post;
+				reader>>contact;
+				reader>>edited;
+				//now form the serialized bytearray with only SmfPost
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<post;
+				writer<<contact;
+				writer<<edited;
+				}
+				break;
+			case SmfPictureDescription:
+			case SmfPictureUpload:
+				{
+				SmfProvider provider;
+				SmfPicture picture;
+				reader>>provider;
+				reader>>picture;
+				//now form the serialized bytearray with only SmfPicture
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<picture;
+				}
+				break;
+			case SmfPictureMultiUpload:
+				{
+				SmfProvider provider;
+				SmfPictureList pictureList;
+				reader>>provider;
+				reader>>pictureList;
+				//now form the serialized bytearray with only SmfPicture
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<pictureList;
+				}
+				break;
+			case SmfPicturePostComment:
+				{
+				SmfProvider provider;
+				SmfPicture picture;
+				SmfComment comment;
+				reader>>provider;
+				reader>>picture;
+				reader>>comment;
+				//now form the serialized bytearray with only SmfPicture
+				QDataStream writer(&dataTobeSent,QIODevice::WriteOnly);
+				writer<<picture;
+				writer<<comment;
+				}
+				break;
+			default:
+				defaultCase = true;
+				break;
+			}
+		//When xtra info to be sent to plugin manager
+		if(!defaultCase)
+			{
+				m_pluginManager->createRequest(requestID,pluginID,requestTypeID,dataTobeSent);
+			}
+		//when plugin manager needs to xtra info
+		else
+			{
+			QByteArray arr;
+			m_pluginManager->createRequest(requestID,pluginID,requestTypeID,arr);
+			}
+	}
+/**
+ * This slot is invoked when CM finishes the authorization of the client.
+ * @param authID As it contains the session ptr, sever directly invokes the session's API to notify success
+ */
+void SmfServer::clientAuthorizationFinished(bool success,SmfClientAuthID authID )
+	{
+	//TODO:- implement this api in session class
+	//note:- in case success is false client completes the request with SmfErrClientAuthFailed
+	//TODO:- define set of smf wide error after consulting with other module owners
+	authID.session->clientathorizationFinished(success);
+	}
+/**
+ * This API is called by PM once its done with request and parsing
+ * @param requestID The request id which is completed
+ * @param parsedData Serialized data(as per request type) filled by PM
+ * @param error Error occured
+ * TODO:- should use smf wide global errors instead
+ */
+void SmfServer::resultsAvailable(int requestID,QByteArray* parsedData,SmfError error)
+	{
+	m_SmfServerPrivate->writeLog("SmfServer::resultsAvailable");
+	m_SmfServerPrivate->writeLog("requestID=");
+	m_SmfServerPrivate->writeLog(QString::number(requestID));
+	m_SmfServerPrivate->writeLog("parsedData->size()=");
+	m_SmfServerPrivate->writeLog(QString::number(parsedData->size()));
+	m_SmfServerPrivate->writeLog("Error=");
+	m_SmfServerPrivate->writeLog(QString::number(error));
+	//Serialize error followed by actual data
+	QByteArray dataWithError;
+	QDataStream writer(&dataWithError,QIODevice::WriteOnly);
+	writer<<error;
+	writer<<*(parsedData);
+	//find out the appropriate session and request id and service that
+	m_SmfServerPrivate->findAndServiceclient(requestID,&dataWithError,error);
+	}
+/**
+ * Seems reduntant in symbian as client is served with RMessage2::Complete()
+ */
+void SmfServer::serviceClient(QByteArray* parsedData)
+	{
+	Q_UNUSED(parsedData);
+	}
+/**
+ * Used by PM to get a list of tokens
+ * TODO:- cross check the params
+ */
+void SmfServer::getAuthenticationKeys(int pluginID,QStringList& keys,QStringList& urls)
+	{
+	//SMF-CM communication will be via CM client
+	//TODO:- do it properly as per CM client impl
+	//CMclient->getKeys(pluginID,keys,urls);
+	Q_UNUSED(pluginID);
+	Q_UNUSED(keys);
+	Q_UNUSED(urls);
+	}
+
+/**
+ * This is called when CMclient notifies client expiry.
+ * @param type notification type, set of enums for future expansion
+ * @param id Plugin Id for which the authentication has expired
+ */
+void SmfServer::authenticationKeysExpired(NotificationType type,SmfPluginID id)
+	{
+	//resend the notify request
+	//CMclient->requestAuthExpiryNotify();
+	Q_UNUSED(type);
+	Q_UNUSED(id);
+	}
+
+void SmfServer::writeLog(QString log) const
+	{
+#ifdef WRITE_LOG
+	QFile file("c:\\data\\SmfServerLogs.txt");
+    if (!file.open(QIODevice::Append | QIODevice::Text))
+	         ;
+    QTextStream out(&file);
+    out << log << "\n";
+    file.close();
+#else
+    Q_UNUSED(log);
+#endif
+	}