smf/smfservermodule/smfclient/smfactivityfetcher_p.cpp
changeset 25 a180113055cb
parent 18 013a02bf2bb0
child 26 83d6a149c755
equal deleted inserted replaced
24:1cee9f1b95e0 25:a180113055cb
    46 		delete m_SmfClientPrivate;
    46 		delete m_SmfClientPrivate;
    47 		m_SmfClientPrivate = NULL;
    47 		m_SmfClientPrivate = NULL;
    48 		}
    48 		}
    49 	}
    49 	}
    50 
    50 
    51 void SmfActivityFetcherPrivate::selfActivities(int pageNum, int perPage)
    51 SmfError SmfActivityFetcherPrivate::selfActivities(int pageNum, int perPage)
    52 	{
    52 	{
       
    53 	SmfError err = SmfNoError;
    53 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
    54 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
    54 	//serialize start
    55 	//serialize start
    55 	m_serializedDataToServer.clear();
    56 	m_serializedDataToServer.clear();
    56 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
    57 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
    57 	//SmfProvider
    58 	//SmfProvider
    58 	write<<*m_baseProvider;
    59 	write<<*m_baseProvider;
    59 	m_argFlag = 1;
    60 	
    60 	write<<m_argFlag;
    61 	QByteArray dataToPlugins;
    61 	write<<pageNum;
    62 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);
    62 	write<<m_argFlag;
    63 	m_argFlag = 1;
    63 	write<<perPage;
    64 	streamToPlugin<<m_argFlag;
       
    65 	streamToPlugin<<pageNum;
       
    66 	streamToPlugin<<m_argFlag;
       
    67 	streamToPlugin<<perPage;
       
    68 	
       
    69 	write<<dataToPlugins;
    64 	//serialize end
    70 	//serialize end
    65 	
    71 	
    66 	QString intfName(activityFetcherInterface);
    72 	QString intfName(activityFetcherInterface);
    67 	int max = MaxSmfActivityEntrySize*perPage;
    73 	int max = MaxSmfActivityEntrySize*perPage;
    68 	
    74 	
    69 	//call private impl's send method
    75 	//call private impl's send method
    70 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
    76 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
    71 			SmfActivitySelfActivity, max);
    77 			SmfActivitySelfActivity, max);
    72 	}
    78 	return err;
    73 
    79 	}
    74 void SmfActivityFetcherPrivate::friendsActivities(const SmfContact & aFriend, int pageNum, int perPage)
    80 
    75 	{
    81 SmfError SmfActivityFetcherPrivate::friendsActivities(const SmfContact & aFriend, int pageNum, int perPage)
       
    82 	{
       
    83 	SmfError err = SmfNoError;
    76 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
    84 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
    77 	//serialize start
    85 	//serialize start
    78 	m_serializedDataToServer.clear();
    86 	m_serializedDataToServer.clear();
    79 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
    87 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
    80 	//SmfProvider
    88 	//SmfProvider
    81 	write<<*m_baseProvider;
    89 	write<<*m_baseProvider;
    82 	m_argFlag = 1;
    90 	
    83 	write<<m_argFlag;
    91 	QByteArray dataToPlugins;
    84 	write<<aFriend;
    92 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);
    85 	write<<m_argFlag;
    93 	m_argFlag = 1;
    86 	write<<pageNum;
    94 	streamToPlugin<<m_argFlag;
    87 	write<<m_argFlag;
    95 	streamToPlugin<<aFriend;
    88 	write<<perPage;
    96 	streamToPlugin<<m_argFlag;
    89 	
    97 	streamToPlugin<<pageNum;
       
    98 	streamToPlugin<<m_argFlag;
       
    99 	streamToPlugin<<perPage;
       
   100 	
       
   101 	write<<dataToPlugins;
       
   102 		
    90 	QString intfName(activityFetcherInterface);
   103 	QString intfName(activityFetcherInterface);
    91 	int max = MaxSmfActivityEntrySize*perPage;
   104 	int max = MaxSmfActivityEntrySize*perPage;
    92 	
   105 	
    93 	//call private impl's send method
   106 	//call private impl's send method
    94 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
   107 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
    95 			SmfActivityFriendsActivities, max);
   108 			SmfActivityFriendsActivities, max);
    96 	}
   109 	return err;
    97 
   110 	}
    98 void SmfActivityFetcherPrivate::filtered(QList<SmfActivityObjectType> filters, int pageNum, int perPage)
   111 
    99 	{
   112 SmfError SmfActivityFetcherPrivate::filtered(QList<SmfActivityObjectType> filters, int pageNum, int perPage)
       
   113 	{
       
   114 	SmfError err = SmfNoError;
   100 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
   115 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
   101 	
   116 	
   102 	//serialize start
   117 	//serialize start
   103 	m_serializedDataToServer.clear();
   118 	m_serializedDataToServer.clear();
   104 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
   119 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
   105 	//SmfProvider
   120 	//SmfProvider
   106 	write<<*m_baseProvider;
   121 	write<<*m_baseProvider;
   107 	m_argFlag = 1;
   122 	
   108 	write<<m_argFlag;
   123 	QByteArray dataToPlugins;
   109 	write<<filters;
   124 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);
   110 	write<<m_argFlag;
   125 	m_argFlag = 1;
   111 	write<<pageNum;
   126 	streamToPlugin<<m_argFlag;
   112 	write<<m_argFlag;
   127 	streamToPlugin<<filters;
   113 	write<<perPage;
   128 	streamToPlugin<<m_argFlag;
       
   129 	streamToPlugin<<pageNum;
       
   130 	streamToPlugin<<m_argFlag;
       
   131 	streamToPlugin<<perPage;
       
   132 	
       
   133 	write<<dataToPlugins;
   114 	
   134 	
   115 	QString intfName(activityFetcherInterface);
   135 	QString intfName(activityFetcherInterface);
   116 	int max = MaxSmfActivityEntrySize*perPage;
   136 	int max = MaxSmfActivityEntrySize*perPage;
   117 	
   137 	
   118 	//call private impl's send method
   138 	//call private impl's send method
   119 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
   139 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
   120 			SmfActivityFiltered, max);
   140 			SmfActivityFiltered, max);
   121 	}
   141 	return err;
   122 
   142 	}
   123 void SmfActivityFetcherPrivate::customRequest ( const int& operationId, QByteArray* customData )
   143 
   124 	{
   144 SmfError SmfActivityFetcherPrivate::customRequest ( const int& operationId, QByteArray* customData )
   125 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
   145 	{
   126 	
   146 	SmfError err = SmfNoError;
   127 	//serialize start
   147 	SmfProvider* m_baseProvider = m_activityFetcher->getProvider();
   128 	m_serializedDataToServer.clear();
   148 	
   129 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
   149 	//serialize start
   130 	write<<*m_baseProvider;
   150 	m_serializedDataToServer.clear();
   131 	m_argFlag = 1;
   151 	QDataStream write(&m_serializedDataToServer,QIODevice::WriteOnly);
   132 	write<<operationId;
   152 	write<<*m_baseProvider;
       
   153 	
       
   154 	QByteArray dataToPlugins;
       
   155 	QDataStream streamToPlugin(&dataToPlugins, QIODevice::WriteOnly);
       
   156 	m_argFlag = 1;
       
   157 	streamToPlugin<<m_argFlag;
       
   158 	streamToPlugin<<operationId;
   133 	if(customData)
   159 	if(customData)
   134 		{
   160 		{
   135 		write<<m_argFlag;
   161 		streamToPlugin<<m_argFlag;
   136 		write<<*customData;
   162 		streamToPlugin<<*customData;
   137 		}
   163 		}
   138 	else
   164 	else
   139 		{
   165 		{
   140 		m_argFlag = 0;
   166 		m_argFlag = 0;
   141 		write<<m_argFlag;
   167 		streamToPlugin<<m_argFlag;
   142 		}
   168 		}
       
   169 	
       
   170 	write<<dataToPlugins;
   143 	
   171 	
   144 	QString intfName(activityFetcherInterface);
   172 	QString intfName(activityFetcherInterface);
   145 //ToDo:- How much size to allocate for custom data? keeping MaxSmfActivityEntrySize for now
   173 //ToDo:- How much size to allocate for custom data? keeping MaxSmfActivityEntrySize for now
   146 	int maxAllocation = MaxSmfActivityEntrySize;
   174 	int maxAllocation = MaxSmfActivityEntrySize;
   147 	
   175 	
   148 	//call private impl's send method
   176 	//call private impl's send method
   149 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
   177 	m_SmfClientPrivate->sendRequest(m_serializedDataToServer, intfName,
   150 			SmfActivityCustomRequest, maxAllocation);
   178 			SmfActivityCustomRequest, maxAllocation);
   151 	}
   179 	return err;
       
   180 	}
       
   181 
       
   182 SmfError SmfActivityFetcherPrivate::cancelRequest()
       
   183 	{
       
   184 	qDebug()<<"Inside SmfActivityFetcherPrivate::cancelRequest()";
       
   185 	QByteArray notused;
       
   186 	QByteArray retData = m_SmfClientPrivate->sendSyncRequest(notused,SmfCancelRequest,1000, notused);
       
   187 	
       
   188 	//De-serialize it into SmfError
       
   189 	QDataStream reader(&retData,QIODevice::ReadOnly);
       
   190 	int val;
       
   191 	reader>>val;
       
   192 	SmfError error = (SmfError) val;
       
   193 	return error;
       
   194 	}
       
   195 
   152 
   196 
   153 void SmfActivityFetcherPrivate::resultsAvailable(QByteArray result,SmfRequestTypeID opcode, SmfError error)
   197 void SmfActivityFetcherPrivate::resultsAvailable(QByteArray result,SmfRequestTypeID opcode, SmfError error)
   154 	{
   198 	{
   155 	qDebug()<<"SmfActivityFetcherPrivate::resultsAvailable";
   199 	qDebug()<<"SmfActivityFetcherPrivate::resultsAvailable";
   156 	qDebug()<<"opcode = "<<opcode;
   200 	qDebug()<<"opcode = "<<opcode;