/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of the sync api's of the contact sapi's.
*
*/
//user includes
#include "contactservice.h"
#include "contactsynccallback.h"
/*
-----------------------------------------------------------------------------
CContactService :: GetListL
Description : synchronous implementation of GetList api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C
CContactIter* CContactService::GetListL(Ttype atype,
const TDesC8& aContactId,
const TDesC& aSearchVal,
CSearchFields* aSearchFields,
TOrder aSortOrder,
const TDesC& aStoreUri,
TCmdType aval)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,GetListL(callback,
0,
atype,
aContactId,
aSearchVal,
aSearchFields,
aSortOrder,
aStoreUri,
aval));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(KErrNone != err)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if(KErrNone != error)
{
User::Leave(error);
}
CContactIter* tempIter = callback->GetIter();
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
return tempIter;
}
/*
-----------------------------------------------------------------------------
CContactService :: GetIdsL
Description : synchronous implementation of GetIds api.
Return values : RPointerArray<HBufC8>&
-----------------------------------------------------------------------------
*/
EXPORT_C
RPointerArray<HBufC8>& CContactService::GetIdsL(Ttype atype,
const TDesC& aSearchVal,
CSearchFields* aSearchFields,
TOrder aSortOrder,
const TDesC& aStoreUri,
TCmdType aval)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,GetListL(callback,
0,
atype,
KNullDesC8,
aSearchVal,
aSearchFields,
aSortOrder,
aStoreUri,
aval));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(KErrNone != err)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if(KErrNone != error)
{
User::Leave(error);
}
RPointerArray<HBufC8>* tempArray = new (ELeave) RPointerArray<HBufC8>;
//get the array of ids of contacts/groups
callback->GetArray(tempArray);
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
return *tempArray;
}
/*
-----------------------------------------------------------------------------
CContactService :: AddL
Description : synchronous implementation of AddL api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C
HBufC8* CContactService:: AddL( CSingleContact* aContact,
const TDesC8& aGroupId,
const TDesC& aGroupLabel,
const TDesC& aStoreUri)
{
iErrKey = 0;
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,AddL(callback,
0,
aContact,
aGroupId,
aGroupLabel,
aStoreUri));
//TRAP harness is used to unset the sync flag in leaving condition
//since we are using the same async apis for sync implementation
if(err!= KErrNone)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if( error!= KErrNone )
{
if(error == KErrNotSupported && callback->iErrKey != 0)
{
iErrKey = callback->iErrKey;
}
User::Leave(error);
}
HBufC8* cntIdVal = callback->GetId();
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
return cntIdVal;
}
/*
-----------------------------------------------------------------------------
CContactService :: DeleteL
Description : synchronous implementation of DeleteL api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C void CContactService:: DeleteL(RPointerArray<TDesC8>& aContactIdArray,
const TDesC& aStoreUri)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,DeleteL(callback,
0,
aContactIdArray,
aStoreUri));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(err!= KErrNone)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if( error!= KErrNone )
{
User::Leave(error);
}
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
}
/*
-----------------------------------------------------------------------------
CContactService :: OrganiseGroupsL
Description : synchronous implementation of OrganiseGroupsL api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C void CContactService:: OrganiseGroupsL( const TDesC8& aGroupId,
RPointerArray<TDesC8>& aContactIdArray,
TBool aAssociateFlag,
const TDesC& aStoreUri)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
//TInt err = KErrNone;
TRAPD(err,OrganiseGroupsL(callback,
0,
aGroupId,
aContactIdArray,
aAssociateFlag,
aStoreUri));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(err!= KErrNone)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if(error!= KErrNone)
{
User::Leave(error);
}
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
}
/*
-----------------------------------------------------------------------------
CContactService :: ExportVCardL
Description : synchronous implementation of ExportVCardL api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C void CContactService::ExportVCardL(const TFileName& aFileName,
const TDesC8& aContactId,
const TDesC& aStoreUri)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,ExportVCardL(callback,
0,
aFileName,
aContactId,
aStoreUri));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(err!= KErrNone)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if( error!= KErrNone )
{
User::Leave(error);
}
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
}
/*
-----------------------------------------------------------------------------
CContactService :: ImportVCardToStoreL
Description : synchronous implementation of ImportVCardToStoreL api.
Return values : CContactIter*
-----------------------------------------------------------------------------
*/
EXPORT_C void CContactService::ImportVCardToStoreL(const TFileName& aFilename,
const TDesC& aStoreUri)
{
//create the callback object internally
CContactSyncCallback* callback = new(ELeave) CContactSyncCallback();
CleanupStack::PushL(callback);
//create the wait scheduler instance
CActiveSchedulerWait* waitScheduler = new(ELeave) CActiveSchedulerWait();
CleanupStack::PushL(waitScheduler);
//needed to stop the scheduler by the callback instance
callback->SetWaitScheduler(waitScheduler);
//call the asynch sapi with all the params
TRAPD(err,ImportVCardToStoreL(callback,
0,
aFilename,
aStoreUri));
//TRAP harness is used to unset the sync flag in leaving condition
//since we r using the same async apis for sync implementation
if(err!= KErrNone)
{
User::Leave(err);
}
//start the wait scheduler and wait untill the operation finishes
waitScheduler->Start();
//Unset the callbak pointer
callback->SetWaitScheduler(NULL);
//check for any errors
TInt error = callback->GetErrorCode();
if( error!= KErrNone )
{
User::Leave(error);
}
CleanupStack::PopAndDestroy(waitScheduler);
CleanupStack::PopAndDestroy(callback);
}