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  * Private Implementation of Relation Manager

    17  * 

    18  */

    19 

    20 #include "smfrelationmgr.h"

    21 #include "smfrelationmgr_p.h"

    22 

    23 #ifdef Q_OS_SYMBIAN

    24 	#include "smfclientsymbian.h"

    25 #else

    26 	#include "smfclientqt.h"

    27 #endif

    28 

    29 

    30 SmfRelationMgrPrivate::SmfRelationMgrPrivate(SmfRelationMgr* relnMngr)

    31 	{

    32 	Q_UNUSED(relnMngr)

    33 #ifdef Q_OS_SYMBIAN

    34 	//private impl for symbian

    35 	m_SmfClientPrivate = CSmfClientSymbian::NewL();

    36 #endif

    37 	}

    38 

    39 SmfRelationMgrPrivate::~SmfRelationMgrPrivate()

    40 	{

    41 	if(m_SmfClientPrivate)

    42 		{

    43 		delete m_SmfClientPrivate;

    44 		m_SmfClientPrivate = NULL;

    45 		}

    46 	}

    47 

    48 SmfRelationId SmfRelationMgrPrivate::create( SmfProvider *provider, SmfContact *contact)

    49 	{

    50 	m_dataForDSM.clear();

    51 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

    52 	if(provider)

    53 		{

    54 		m_argFlag = 1;

    55 		writeStream<<m_argFlag;

    56 		writeStream<<*provider;

    57 		}

    58 	else

    59 		{

    60 		m_argFlag = 0;

    61 		writeStream<<m_argFlag;

    62 		}

    63 	if(contact)

    64 		{

    65 		m_argFlag = 1;

    66 		writeStream<<m_argFlag;

    67 		writeStream<<*contact;

    68 		}

    69 	else

    70 		{

    71 		m_argFlag = 0;

    72 		writeStream<<m_argFlag;

    73 		}

    74 	

    75 	m_dataFromDSM.clear();

    76 	SmfError err = SmfNoError;

    77 	SmfRelationId relnId;

    78 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationCreate,m_dataForDSM,err,maxSmfRelationIdSize);

    79 	if(err == SmfNoError)

    80 		{

    81 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

    82 		readStream>>relnId;

    83 		}

    84 	else

    85 		{

    86 		User::Panic(_L("DSM err = "),err);

    87 		}

    88 	return relnId;

    89 	}

    90 

    91 SmfError SmfRelationMgrPrivate::associate( SmfRelationId& relation,

    92 		const SmfContact* contact, SmfProvider* provider)

    93 	{

    94 	m_dataForDSM.clear();

    95 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

    96 	writeStream<<relation;

    97 	if(contact)

    98 		{

    99 		m_argFlag = 1;

   100 		writeStream<<m_argFlag;

   101 		writeStream<<*contact;

   102 		}

   103 	else

   104 		{

   105 		m_argFlag = 0;

   106 		writeStream<<m_argFlag;

   107 		}

   108 	if(provider)

   109 		{

   110 		m_argFlag = 1;

   111 		writeStream<<m_argFlag;

   112 		writeStream<<*provider;

   113 		}

   114 	else

   115 		{

   116 		m_argFlag = 0;

   117 		writeStream<<m_argFlag;

   118 		}

   119 	

   120 	m_dataFromDSM.clear();

   121 	SmfError err = SmfNoError;

   122 	int maxAlloc = 100;

   123 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationAssociate,m_dataForDSM,err,maxAlloc);

   124 	if(err == SmfNoError)

   125 		{

   126 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   127 		int errInt;

   128 		readStream>>errInt;

   129 		err = (SmfError)errInt;

   130 		}

   131 	else

   132 		{

   133 		User::Panic(_L("DSM err = "),err);

   134 		}

   135 	return err;

   136 	}

   137 

   138 SmfError SmfRelationMgrPrivate::remove(SmfRelationId& relation,const SmfContact* contact)

   139 	{

   140 	m_dataForDSM.clear();

   141 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   142 	writeStream<<relation;

   143 	if(contact)

   144 		{

   145 		m_argFlag = 1;

   146 		writeStream<<m_argFlag;

   147 		writeStream<<*contact;

   148 		}

   149 	else

   150 		{

   151 		m_argFlag = 0;

   152 		writeStream<<m_argFlag;

   153 		}

   154 	

   155 	m_dataFromDSM.clear();

   156 	SmfError err = SmfNoError;

   157 	int maxAlloc = 100;

   158 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationRemove,m_dataForDSM,err,maxAlloc);

   159 	if(err == SmfNoError)

   160 		{

   161 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   162 		int errInt;

   163 		readStream>>errInt;

   164 		err = (SmfError)errInt;

   165 		}

   166 	else

   167 		{

   168 		const QString errStr = QString::number(err);

   169 		Q_ASSERT_X(1,"SmfRelationMgrPrivate::remove","error");

   170 		}

   171 	return err;

   172 	}

   173 

   174 SmfRelationItem* SmfRelationMgrPrivate::searchById(const SmfRelationId& relation)

   175 	{

   176 	m_dataForDSM.clear();

   177 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   178 	writeStream<<relation;

   179 	

   180 	m_dataFromDSM.clear();

   181 	int maxAlloc = MaxSmfContactSize;

   182 	SmfError err = SmfNoError;

   183 	SmfRelationItem *relnItem = NULL;

   184 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationSearchById,m_dataForDSM,err,maxAlloc);

   185 	if(err == SmfNoError)

   186 		{

   187 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   188 		m_argFlag = 0;

   189 		readStream>>m_argFlag;

   190 		if(m_argFlag)

   191 			{

   192 			relnItem = new SmfRelationItem;

   193 			readStream>>*(relnItem);

   194 			}

   195 		}

   196 	else

   197 		{

   198 		User::Panic(_L("DSM err = "),err);

   199 		}

   200 	return relnItem;

   201 	}

   202 

   203 SmfRelationId SmfRelationMgrPrivate::searchByContact( SmfContact contact)

   204 	{

   205 	m_dataForDSM.clear();

   206 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   207 	writeStream<<contact;

   208 	

   209 	m_dataFromDSM.clear();

   210 	int maxAlloc = 1000;

   211 	SmfError err = SmfNoError;

   212 	SmfRelationId relnId;

   213 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationSearchByContact,m_dataForDSM,err,maxAlloc);

   214 	if(err == SmfNoError)

   215 		{

   216 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   217 		readStream>>relnId;

   218 		}

   219 	else

   220 		{

   221 		User::Panic(_L("DSM err = "),err);

   222 		}

   223 	return relnId;

   224 	}

   225 

   226 //number of contacts in a relation

   227 uint SmfRelationMgrPrivate::count(SmfRelationId relation)

   228 	{

   229 	m_dataForDSM.clear();

   230 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   231 	writeStream<<relation;

   232 	

   233 	m_dataFromDSM.clear();

   234 	SmfError err = SmfNoError;

   235 	int maxAlloc = 100;

   236 	uint count;

   237 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationCount,m_dataForDSM,err,maxAlloc);

   238 	if(err == SmfNoError)

   239 		{

   240 		QDataStream readStream(&m_dataForDSM,QIODevice::ReadOnly);

   241 		readStream>>count;

   242 		}

   243 	else

   244 		{

   245 		User::Panic(_L("DSM err = "),err);

   246 		}

   247 	return count;

   248 	}

   249 

   250 SmfRelationItem* SmfRelationMgrPrivate::get(SmfRelationId& relation, quint32 index)

   251 	{

   252 	m_dataForDSM.clear();

   253 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   254 	writeStream<<relation;

   255 	writeStream<<index;

   256 	

   257 	m_dataFromDSM.clear();

   258 	SmfError err = SmfNoError;

   259 	int maxAlloc = maxSmfRelationItemSize;

   260 	SmfRelationItem* relationItem = NULL;

   261 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationGet,m_dataForDSM,err,maxAlloc);

   262 	if(err == SmfNoError)

   263 		{

   264 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   265 		m_argFlag = 0;

   266 		readStream>>m_argFlag;

   267 		if(m_argFlag)

   268 			{

   269 			relationItem = new SmfRelationItem;

   270 			readStream>>*(relationItem);

   271 			}

   272 		}

   273 	else

   274 		{

   275 		User::Panic(_L("DSM err = "),err);

   276 		}

   277 	return relationItem;

   278 	}

   279 

   280 QList<SmfRelationItem> SmfRelationMgrPrivate::getAll(SmfRelationId& relation)

   281 	{

   282 	m_dataForDSM.clear();

   283 	

   284 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   285 	writeStream<<relation;

   286 		

   287 	m_dataFromDSM.clear();

   288 	SmfError err = SmfNoError;

   289 	QList<SmfRelationItem> relationItemList;

   290 	int maxAlloc = maxSmfRelationItemSize*maxRelationItems;

   291 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationGetAll,m_dataForDSM,err,maxAlloc);

   292 	if(err == SmfNoError)

   293 		{

   294 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   295 		readStream>>relationItemList;

   296 		}

   297 	else

   298 		{

   299 		User::Panic(_L("DSM err = "),err);

   300 		}

   301 	return relationItemList;

   302 	}

   303 

   304 QList<SmfRelationId> SmfRelationMgrPrivate::getAllRelations()

   305 	{

   306 	m_dataForDSM.clear();

   307 	

   308 	m_dataFromDSM.clear();

   309 	SmfError err = SmfNoError;

   310 	int maxAlloc = 1000*maxRelationItems;

   311 	QList<SmfRelationId> relationIdList;

   312 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationGetAllRelations,m_dataForDSM,err,maxAlloc);

   313 	if(err == SmfNoError)

   314 		{

   315 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   316 		readStream>>relationIdList;

   317 		}

   318 	else

   319 		{

   320 		User::Panic(_L("DSM err = "),err);

   321 		}

   322 	return relationIdList;

   323 	}

   324 

   325 SmfError SmfRelationMgrPrivate::Delete(SmfRelationId& relation)

   326 	{

   327 	m_dataForDSM.clear();

   328 	

   329 	QDataStream writeStream(&m_dataForDSM,QIODevice::WriteOnly);

   330 	writeStream<<relation;

   331 		

   332 	m_dataFromDSM.clear();

   333 	SmfError err = SmfNoError;

   334 	int maxAlloc = 100;

   335 	m_dataFromDSM = m_SmfClientPrivate->sendDSMSyncRequest(SmfRelationDeleteRelation,m_dataForDSM,err,maxAlloc);

   336 	if(err == SmfNoError)

   337 		{

   338 		QDataStream readStream(&m_dataFromDSM,QIODevice::ReadOnly);

   339 		int errInt;

   340 		readStream>>errInt;

   341 		err = (SmfError)errInt;

   342 		}

   343 	else

   344 		{

   345 		User::Panic(_L("DSM err = "),err);

   346 		}

   347 	return err;

   348 	}