diff -r a36b1e19a461 -r 989d2f495d90 serviceproviders/sapi_calendar/src/calendarinterface.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/serviceproviders/sapi_calendar/src/calendarinterface.cpp Fri Jul 03 15:51:24 2009 +0100 @@ -0,0 +1,2933 @@ +/* +* 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: +* +*/ + + +#include +#include + + +#include "serviceerrno.h" +#include "calendarheader.h" +#include "entryattributes.h" +#include "calendarservice.h" +#include "calendarinterface.h" +#include "calendarcallback.h" +#include "calendariterableimpl.h" + +using namespace LIW; + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CCalendarInterface* CCalendarInterface::NewL() + { + CCalendarInterface* self = new (ELeave) CCalendarInterface(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } +// --------------------------------------------------------------------------- +// Destructor. +// --------------------------------------------------------------------------- +// +CCalendarInterface::~CCalendarInterface() + { + TInt count = iArrayCalEntryList.Count(); + for(TInt index = 0; index < count; index++ ) + { + iArrayCalEntryList[index]->SetResourceFree(); + } + + iArrayCalEntryList.Reset(); + delete iCalService; + delete iErrorMessage; + } + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CCalendarInterface::CCalendarInterface() + { + } + +// --------------------------------------------------------------------------- +// Symbian Constructor +// --------------------------------------------------------------------------- +// +void CCalendarInterface::ConstructL() + { + iCalService = CCalendarService::NewL(); + } + +// --------------------------------------------------------------------------- +// Executes the SAPI as per params +// --------------------------------------------------------------------------- +// +void CCalendarInterface::ExecuteCmdL( const TDesC8& aCmdName, + const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback ) + { + TInt errcode = KErrNotSupported; + TInt32 transactionId = -1; + + aOutParamList.AppendL(TLiwGenericParam( KErrorCode, + TLiwVariant( ErrCodeConversion( KErrNone )))); + + TBool posBased; + + TPtrC contentType = GetContentType( aInParamList, posBased ); + + if ( ( contentType.CompareF( KContentCalendar ) != 0 ) && + ( contentType.CompareF( KContentCalendarEntry ) != 0 ) && + ( aCmdName.CompareF( KCmdCancel ) != 0) ) + { + errcode = KErrArgument; + AppendErrorMessageL( aCmdName, KContentType, KInvalid ); + } + + else if (( aCallback && !( KLiwOptASyncronous & aCmdOptions )) || + ( !aCallback && ( KLiwOptASyncronous & aCmdOptions )) ) + { + errcode = KErrArgument; + AppendErrorMessageL(aCmdName, KNullDesC8, _L("Insufficent arguments for asynchronous request")); + } + + else if ( aCmdName.CompareF( KCmdAdd ) == 0 ) + { + if( !aCallback ) + { + if ( contentType.CompareF( KContentCalendar ) == 0 ) + { + TRAP(errcode, AddCalendarL( aInParamList, aOutParamList, posBased )); + } + else if ( contentType.CompareF( KContentCalendarEntry ) == 0 ) + { + TRAP(errcode, AddCalendarEntryL( aInParamList, aOutParamList, posBased )); + } + } + else + { + AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported); + } + } + + else if ( aCmdName.CompareF( KCmdDelete ) == 0 ) + { + if( contentType.CompareF( KContentCalendar ) == 0 ) + { + if ( !aCallback )//deletion of calendars only synchronous + { + TRAP(errcode, DeleteCalendarL( aInParamList, posBased) ); + } + else + { + AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported); + } + } + else if ( contentType.CompareF( KContentCalendarEntry ) == 0) + { + TRAP(errcode, DeleteCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId )); + } + } + + else if ( aCmdName.CompareF( KCmdImport ) == 0 ) + { + if ( contentType.CompareF( KContentCalendarEntry ) == 0 ) + { + TRAP(errcode, ImportCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId )); + } + else + { + AppendErrorMessageL( aCmdName, KContentType, KInvalid ); + } + } + + else if ( aCmdName.CompareF( KCmdExport ) == 0 ) + { + if ( contentType.CompareF( KContentCalendarEntry ) == 0 ) + { + TRAP(errcode, ExportCalendarEntryL( aInParamList, aOutParamList, aCmdOptions, aCallback, posBased, transactionId )); + } + else + { + AppendErrorMessageL( aCmdName, KContentType, KInvalid ); + } + } + + else if ( aCmdName.CompareF( KCmdGetList ) == 0 ) + { + if( !aCallback ) + { + if ( contentType.CompareF( KContentCalendar ) == 0 ) + { + TRAP(errcode, GetListCalendarL( aInParamList, aOutParamList, posBased )); + } + else if ( contentType.CompareF( KContentCalendarEntry ) == 0 ) + { + TRAP(errcode, GetListCalendarEntryL( aInParamList, aOutParamList, posBased )); + } + } + else + { + AppendErrorMessageL(aCmdName, KNullDesC8, KAsyncNotSupported); + } + } + + else if ( aCmdName.CompareF( KCmdReqNot ) == 0 ) + { + if (( contentType.CompareF( KContentCalendarEntry ) == 0 ) && + aCallback && ( KLiwOptASyncronous & aCmdOptions ) ) + { + TRAP(errcode, RequestNotificationL(aInParamList, aCallback, posBased, transactionId )); + } + else if( !aCallback || !( KLiwOptASyncronous & aCmdOptions )) + { + AppendErrorMessageL(aCmdName, KNullDesC8, KInvalidAsyncParam); + } + else + { + AppendErrorMessageL( aCmdName, KContentType, KInvalid ); + } + } + + else if ( aCmdName.CompareF( KCmdCancel ) == 0 ) + { + TInt32 transactionId; + if( (KLiwOptCancel & aCmdOptions ) && !aCallback ) + { + TRAP( errcode, GetTransactionIdL( aInParamList, transactionId ) ); + if( errcode == KErrNone ) + { + errcode = iCalService->Cancel( transactionId ); + if ( errcode == KErrNotFound ) + { + AppendErrorMessageL( aCmdName, KTransactionID, KInvalid ); + } + else if( errcode == KErrInUse ) + { + AppendErrorMessageL( aCmdName, KNullDesC8, KServiceInUse ); + } + } + } + else + { + AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidCancelParam ); + } + } + + else + { + AppendErrorMessageL(aCmdName, KNullDesC8, KCmdInvalid); + } + + // Append transaction id in case of asynchronous requests + if( aCallback && ( KLiwOptASyncronous & aCmdOptions ) && + ( errcode == KErrNone ) && ( transactionId != -1 ) ) + { + aOutParamList.AppendL(TLiwGenericParam( KTransactionID, + TLiwVariant( TInt32( transactionId )))); + } + + if( errcode != KErrNone ) + { + aOutParamList.Reset(); + aOutParamList.AppendL(TLiwGenericParam( KErrorCode, + TLiwVariant(ErrCodeConversion(errcode)))); + + if ( iErrorMessage ) + { + aOutParamList.AppendL(TLiwGenericParam( KErrorMessage, + TLiwVariant(iErrorMessage->Des()))); + delete iErrorMessage; + iErrorMessage = NULL; + } + } + } + +// --------------------------------------------------------------------------- +// Closes the interface +// --------------------------------------------------------------------------- +// +void CCalendarInterface::Close() + { + delete this; + } + +// --------------------------------------------------------------------------- +// Issues Add Calendar request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::AddCalendarL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& /*aOutParamList*/, + const TBool aPosBased ) + { + HBufC* calName = NULL; + GetCalendarNameL( aInParamList, KCmdAdd, KItem, aPosBased, calName ); + if ( calName && calName->Des().Length() ) + { + CleanupStack::PushL(calName); + iCalService->AddL( calName->Des() ); + CleanupStack::PopAndDestroy(calName); + } + else + { + AppendErrorMessageL( KCmdAdd, KCalendarName, KMissing ); + User::Leave( KErrArgument ); + } + } + +// --------------------------------------------------------------------------- +// Issues Add Calendar Entry request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::AddCalendarEntryL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + const TBool aPosBased ) + { + HBufC* calName = NULL; + + GetCalendarNameL( aInParamList, KCmdAdd, KItem, aPosBased, calName ); + + if ( calName ) + { + CleanupStack::PushL(calName); + } + + // Get New entry attributes from input param list + CEntryAttributes* addAttributes = GetAddParametersL( aInParamList, + calName ? calName->Des() : TPtrC(), + aPosBased ); + + CleanupStack::PushL( addAttributes ); + + TUIDSet* uidset = NULL; + + iCalService->AddL( calName ? calName->Des() : TPtrC() , addAttributes, uidset ); + + // Return Uid of the newly added entry + if ( uidset ) + { + CleanupStack::PushL( uidset ); + + HBufC* globalUid = HBufC::NewL( uidset->iGlobalUID->Length() + 1 ); + CleanupStack::PushL( globalUid ); + globalUid->Des().Copy( uidset->iGlobalUID->Des() ); + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant(*globalUid) )); + CleanupStack::PopAndDestroy( globalUid ); + + CleanupStack::Pop( uidset ); + + delete uidset; + + CleanupStack::PopAndDestroy( addAttributes ); + } + else + { + AppendErrorMessageL( KCmdAdd, KNullDesC8, KCmdFailed ); + User::Leave( KErrGeneral ); + } + + if ( calName ) + { + CleanupStack::PopAndDestroy(calName); + } + } + +// --------------------------------------------------------------------------- +// Issues Delete Calendar request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::DeleteCalendarL( const CLiwGenericParamList& aInParamList, TBool aPosBased) + { + HBufC* calName = NULL; + GetCalendarNameL( aInParamList, KCmdDelete, KData, aPosBased, calName ); + if ( calName && calName->Length() ) + { + CleanupStack::PushL( calName ); + if( CheckCalendarInUse( *calName ) ) + { + AppendErrorMessageL( KCmdDelete, KCalendarName, _L(" in use.") ); + User::Leave( KErrInUse ); + } + iCalService->DeleteL( calName->Des() ); + CleanupStack::PopAndDestroy( calName ); + } + else + { + AppendErrorMessageL( KCmdDelete, KCalendarName, KMissing ); + User::Leave( KErrArgument ); + } + } + +// --------------------------------------------------------------------------- +// Issues Delete Calendar Entry request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::DeleteCalendarEntryL( const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& /*aOutParamList*/, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback, + const TBool aPosBased, + TInt32& aTransactionId ) + { + HBufC* calName = NULL; + + GetCalendarNameL( aInParamList, KCmdDelete, KData, aPosBased, calName ); + + if ( calName ) + { + CleanupStack::PushL(calName); + } + + CCalendarFilter* filter = CCalendarFilter::NewL(); + + CleanupStack::PushL(filter); + + // Get filter parameters from input list + GetDeleteEntryFilterL( aInParamList, *filter, aPosBased ); + + // Leave if there was no filter + if( ! filter->Filter() ) + { + AppendErrorMessageL( KCmdDelete, KData, KMissing ); + User::Leave( KErrArgument ); + } + + // Issue asynchronous request if Callback present + if ( aCallback && ( KLiwOptASyncronous & aCmdOptions )) + { + aTransactionId = aCallback->GetTransactionID(); + + CCalCallbackInt* callback = CCalCallbackInt::NewL( aCallback, aInParamList, aTransactionId ); + + CleanupStack::PushL( callback ); + + iCalService->DeleteL( calName ? calName->Des() : TPtrC() , filter, callback ); + + CleanupStack::Pop( callback ); + } + // Synchronous request + else + { + iCalService->DeleteL( calName ? calName->Des() : TPtrC(), filter ); + } + + CleanupStack::PopAndDestroy(filter); + + if ( calName ) + { + CleanupStack::PopAndDestroy(calName); + } + + } + +// --------------------------------------------------------------------------- +// Issues GetList Calendar request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetListCalendarL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + const TBool aPosBased ) + { + const TLiwGenericParam* filter = NULL; + + if ( aPosBased ) + { + if ( aInParamList.Count() > 1 ) + filter = &aInParamList[1]; + } + else + { + TInt pos = 0 ; + filter = aInParamList.FindFirst( pos, KFilter ); + } + + TBool defaultCalendar = EFalse; + + // Extracting "Default" input param + // If True, Only default calendar is returned + if ( filter ) + { + const CLiwMap* inputMap = filter->Value().AsMap(); + if ( inputMap ) + { + TLiwVariant defaultvalue; + if( inputMap->FindL( KDefault, defaultvalue)) + { + ValidateParamTypeL( defaultvalue, LIW::EVariantTypeTBool, + KCmdGetList, KDefault, KInvalid ); + + defaultCalendar = defaultvalue.AsTBool(); + } + defaultvalue.Reset(); + } + else + { + AppendErrorMessageL( KCmdGetList, KFilter, KInvalid ); + User::Leave(KErrArgument); + } + } + + CDesCArray* returnList = NULL; + + // Issue request to Calendar Service + iCalService->GetListL( returnList, defaultCalendar ); + + CleanupStack::PushL( returnList ); + + // Encapsulate the returned list as Iterable + CIterableCalendarList* iterList = CIterableCalendarList::NewL( returnList ); + + CleanupStack::Pop( returnList ); + + CleanupClosePushL( *iterList ); + + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( iterList ))); + + CleanupStack::PopAndDestroy( iterList ); + + } + +// --------------------------------------------------------------------------- +// Issues GetList Calendar Entry request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetListCalendarEntryL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + const TBool aPosBased ) + { + const TLiwGenericParam* filterParam = NULL; + + if ( aPosBased ) + { + if ( aInParamList.Count() > 1 ) + filterParam = &aInParamList[1]; + } + else + { + TInt pos = 0 ; + filterParam = aInParamList.FindFirst( pos, KFilter ); + } + + CCalendarFilter* filter = CCalendarFilter::NewL(); + + CleanupStack::PushL( filter ); + + HBufC* calName = NULL; + + // Extract filter information from input param list + if ( filterParam ) + { + const CLiwMap* inputMap = filterParam->Value().AsMap(); + if ( inputMap ) + { + TLiwVariant param; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , ¶m)); + + + if( inputMap->FindL( KId, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeDesC, + KCmdGetList, KId, KInvalid ); + + //filter->AddGuidL( param.AsData() ); + HBufC8* globalUid = HBufC8::NewL(param.AsDes().Length()); + CleanupStack::PushL( globalUid ); + GetGlobalUid(param.AsDes(), globalUid->Des()); + filter->AddGuidL( globalUid->Des() ); + CleanupStack::PopAndDestroy( globalUid ); + } + + if( inputMap->FindL( KLocalId, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeDesC, + KCmdGetList, KLocalId, KInvalid ); + + //filter->AddLocalUid( param.AsTUint() ); + TCalLocalUid localUid; + GetLocalUid( param.AsDes(), localUid ); + filter->AddLocalUid( localUid ); + } + + if( inputMap->FindL( KStartRange, param)) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdGetList, KStartRange, KInvalid ); + + filter->SetStartTimeL( param.AsTTime() ); + } + + if( inputMap->FindL( KEndRange, param)) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdGetList, KEndRange, KInvalid ); + + filter->SetEndTimeL( param.AsTTime() ); + } + + if( inputMap->FindL( KSearchText, param)) + { + ValidateParamTypeL( param, LIW::EVariantTypeDesC, + KCmdGetList, KSearchText, KInvalid ); + + filter->SetFilterTextL( param.AsDes() ); + } + + if( inputMap->FindL( KEntryType, param)) + { + ValidateParamTypeL( param, LIW::EVariantTypeDesC, + KCmdGetList, _L8("Entry Type") , KInvalid ); + + filter->SetFilterTypeL( param.AsDes() ); + } + + if( inputMap->FindL( KCalendarName, param)) + { + ValidateParamTypeL( param, LIW::EVariantTypeDesC, + KCmdGetList, KCalendarName, KInvalid ); + + calName = param.AsDes().AllocL(); + } + + CleanupStack::Pop( ¶m); + param.Reset(); + } + else + { + AppendErrorMessageL(KCmdGetList, KFilter, KInvalid); + User::Leave(KErrArgument); + } + } + if( calName ) + CleanupStack::PushL(calName); + TPtrC calendarName( calName ? calName->Des() : TPtrC() ); + + // Return list of CalendarEntries if any of LocalUid or GlobalUid is passed as Filter. + if ( ( filter->Filter() & EFilterGUid ) || + ( filter->Filter() & EFilterLUid ) ) + { + CIterableCalEntryList* iterEntryList = CIterableCalEntryList::NewL( *this, calendarName, ETrue ); + CleanupStack::PushL( TCleanupItem(CleanupIterableCalEntry, iterEntryList ) ); + + + if ( filter->Filter() & EFilterLUid ) + { + // In case of LocalUid only one entry is returned. + iCalService->GetListL( calendarName, (filter->LocalUidList())[0], iterEntryList->EntryArray()); + } + else + { + // In case of GlobalUid there can be more than one entry(child entries) + iCalService->GetListL( calendarName, (*filter->GuidList())[0], iterEntryList->EntryArray()); + } + + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( iterEntryList ))); + iterEntryList->DecRef(); + + iArrayCalEntryList.Append( iterEntryList ); + + CleanupStack::Pop( iterEntryList ); + } + // Return list of Instances if none of LocalUid or GlobalUid is passed as Filter. + else + { + CIterableCalEntryList* iterInstList = CIterableCalEntryList::NewL( *this, calendarName, EFalse ); + CleanupStack::PushL( TCleanupItem(CleanupIterableCalEntry, iterInstList ) ); + + iCalService->GetListL( calendarName, filter, iterInstList->InstanceArray()); + + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( iterInstList ))); + iterInstList->DecRef(); + + iArrayCalEntryList.Append( iterInstList ); + + CleanupStack::Pop( iterInstList ); + } + + if ( calName ) + CleanupStack::PopAndDestroy(calName); + + CleanupStack::PopAndDestroy(filter); + } + +// --------------------------------------------------------------------------- +// Issues Import Calendar Entry request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::ImportCalendarEntryL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback , + const TBool aPosBased, + TInt32& aTransactionId ) + { + HBufC8* inputBuffer = NULL; + + HBufC* calName = NULL; + + HBufC* importFile = NULL; + + HBufC8* calendarFormat = NULL; + + // Extract input information from input param list + GetCalendarNameL( aInParamList, KCmdImport, KData, aPosBased, calName ); + if ( calName ) + { + CleanupStack::PushL( calName ); + } + + GetDesCFieldFromMapL( aInParamList, KCmdImport, KData, KImExFileName, aPosBased, importFile ); + if ( importFile ) + { + CleanupStack::PushL( importFile ); + } + + GetDesC8FieldFromMapL( aInParamList, KCmdImport, KData, KInputBuffer, aPosBased, inputBuffer ); + if ( inputBuffer ) + { + CleanupStack::PushL( inputBuffer ); + } + else if ( !importFile ) + { + AppendErrorMessageL( KCmdImport, KImExFileName, KMissing ); + User::Leave( KErrArgument ); + } + + HBufC* tmpFormat = NULL; + GetDesCFieldFromMapL( aInParamList, KCmdImport, KData, KCalendarFormat, aPosBased, tmpFormat ); + if ( tmpFormat ) + { + CleanupStack::PushL( tmpFormat ); + calendarFormat = HBufC8::NewL(tmpFormat->Des().Length()); + calendarFormat->Des().Copy(tmpFormat->Des()); + CleanupStack::PopAndDestroy( tmpFormat ); + CleanupStack::PushL( calendarFormat ); + } + else + { + AppendErrorMessageL( KCmdImport, KCalendarFormat, KMissing ); + User::Leave( KErrArgument ); + } + + + //asynchronous version of import is called if callback is provided + if ( aCallback && ( KLiwOptASyncronous & aCmdOptions )) + { + aTransactionId = aCallback->GetTransactionID(); + + CCalCallbackBaseUIDSet* callback = CCalCallbackBaseUIDSet::NewL( aCallback, aInParamList, aTransactionId); + + CleanupStack::PushL( callback ); + + if ( inputBuffer ) + { + // Import from the input buffer + iCalService->ImportL( calName ? calName->Des() : TPtrC(), + *calendarFormat, *inputBuffer, callback ); + } + else + { + // Import from the given file + iCalService->ImportL( calName ? calName->Des() : TPtrC(), + *calendarFormat , *importFile, callback ); + } + + CleanupStack::Pop( callback ); + } + else //synchronous version of import + { + RPointerArray outputUIDSet;//Push on to CalennupStack + + if ( inputBuffer ) + { + // Import from the input buffer + iCalService->ImportL( calName ? calName->Des() : TPtrC(), + *calendarFormat , *inputBuffer, outputUIDSet ); + } + else + { + // Import from the input file + iCalService->ImportL( calName ? calName->Des() : TPtrC(), + *calendarFormat , *importFile, outputUIDSet ); + } + + // Set output to output param + SetImportOutputL( outputUIDSet, aOutParamList ); + + outputUIDSet.ResetAndDestroy(); + } + + CleanupStack::PopAndDestroy( calendarFormat ); + + if ( inputBuffer ) + CleanupStack::PopAndDestroy( inputBuffer ); + + if ( importFile ) + CleanupStack::PopAndDestroy( importFile ); + + if ( calName ) + CleanupStack::PopAndDestroy( calName ); + } + +// --------------------------------------------------------------------------- +// Issues Export Calendar Entry request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::ExportCalendarEntryL(const CLiwGenericParamList& aInParamList, + CLiwGenericParamList& aOutParamList, + TUint aCmdOptions, + MLiwNotifyCallback* aCallback , + const TBool aPosBased, + TInt32& aTransactionId ) + { + HBufC* calendarName = NULL; + + HBufC8* exportFormat = NULL; + + CCalendarExportParams* calendarExportParams = CCalendarExportParams::NewL(); + + CleanupStack::PushL( calendarExportParams ); + + // Extract input information from input param list + GetCalendarNameL( aInParamList, KCmdExport, KData, aPosBased, calendarName ); + if ( calendarName ) + { + CleanupStack::PushL( calendarName ); + } + + HBufC* tmpFormat = NULL; + GetDesCFieldFromMapL( aInParamList, KCmdExport, KData, KCalendarFormat, aPosBased, tmpFormat ); + if ( tmpFormat ) + { + CleanupStack::PushL( tmpFormat ); + exportFormat = HBufC8::NewL(tmpFormat->Des().Length()); + exportFormat->Des().Copy(tmpFormat->Des()); + CleanupStack::PopAndDestroy( tmpFormat ); + CleanupStack::PushL( exportFormat ); + } + else + { + AppendErrorMessageL( KCmdExport, KCalendarFormat, KMissing ); + User::Leave( KErrArgument ); + } + + // Extract input information from input param list + GetExportInputL( aInParamList , aPosBased , *calendarExportParams ); + + //asynchronous version of Export is called if callback is provided + if ( aCallback && ( KLiwOptASyncronous & aCmdOptions )) + { + aTransactionId = aCallback->GetTransactionID(); + + CCalCallbackBaseBuffer* callback = CCalCallbackBaseBuffer::NewL( aCallback, aInParamList, aTransactionId ); + + CleanupStack::PushL( callback ); + + iCalService->ExportL( calendarName ? calendarName->Des() : TPtrC(), + *exportFormat, calendarExportParams , callback ); + + CleanupStack::Pop( callback ); + } + else //synchronous version of Export + { + HBufC8* outputBuffer = NULL; + + iCalService->ExportL( calendarName ? calendarName->Des() : TPtrC() , + *exportFormat, calendarExportParams , outputBuffer ); + + // outputBuffer is NULL in case export is done to file + if ( outputBuffer ) + { + CleanupStack::PushL( outputBuffer ); + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( *outputBuffer ) ) ); + CleanupStack::PopAndDestroy( outputBuffer ); + } + } + + CleanupStack::PopAndDestroy( exportFormat ); + + if ( calendarName ) + CleanupStack::PopAndDestroy( calendarName ); + + CleanupStack::PopAndDestroy( calendarExportParams ); + } + + +// --------------------------------------------------------------------------- +// Issues Change Notification request to Calendar Service +// --------------------------------------------------------------------------- +// +void CCalendarInterface::RequestNotificationL( const CLiwGenericParamList& aInParamList, + MLiwNotifyCallback* aCallback, + const TBool aPosBased, + TInt32& aTransactionId ) + { + HBufC* calName = NULL; + + GetCalendarNameL( aInParamList, KCmdReqNot, KFilter, aPosBased, calName ); + + if ( calName ) + { + CleanupStack::PushL(calName); + } + + CCalendarFilter* filter = CCalendarFilter::NewL(); + + CleanupStack::PushL(filter); + + // Get Notification filter + GetNotificationFilterL( aInParamList, *filter, aPosBased ); + + aTransactionId = aCallback->GetTransactionID(); + + CCalCallbackChangeNotify* callback = CCalCallbackChangeNotify::NewL( aCallback, aInParamList, aTransactionId ); + + CleanupStack::PushL( callback ); + + // Issue request + iCalService->StartChangeNotifyL( calName ? calName->Des() : TPtrC(), filter, callback ); + + CleanupStack::Pop( callback ); + + CleanupStack::PopAndDestroy(filter); + + if ( calName ) + { + CleanupStack::PopAndDestroy(calName); + } + + } + +// --------------------------------------------------------------------------- +// Get content type from input param list +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetContentType(const CLiwGenericParamList& aInParamList, TBool& aPosBased ) + { + TInt pos = 0; + + const TLiwGenericParam* inContentType = aInParamList.FindFirst( pos, KContentType ); + + TPtrC type; + + if ( inContentType ) + { + type.Set( inContentType->Value().AsDes() ); + aPosBased = EFalse; + } + else + { + if ( aInParamList.Count() > 0 ) + { + inContentType = &aInParamList[0]; + if( inContentType->Name().Compare(KNullDesC8) == 0 ) + { + type.Set( aInParamList[0].Value().AsDes() ); + aPosBased = ETrue; + } + } + } + + return type; + } + +// --------------------------------------------------------------------------- +// Gets the Transaction id +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetTransactionIdL( const CLiwGenericParamList& aInParamList, TInt32& aTransactionId ) + { + TInt pos = 0; + + const TLiwGenericParam* param = aInParamList.FindFirst( pos, + KTransactionID, + EVariantTypeTInt32 ); + if(!param && aInParamList.Count() > 0) + { + param = &aInParamList[0]; + if( param->Name().Compare(KNullDesC8) != 0 ) + { + AppendErrorMessageL( KCmdCancel, KTransactionID, KMissing ); + User::Leave(KErrArgument); + } + } + + if ( param ) + { + TLiwVariant* tempparam = const_cast(& param->Value()); + ValidateParamTypeL( *tempparam, LIW::EVariantTypeTInt32, + KCmdCancel, KTransactionID, KInvalid ); + + aTransactionId = param->Value().AsTInt32(); + } + else + { + AppendErrorMessageL( KCmdCancel, KTransactionID, KMissing ); + User::Leave(KErrArgument); + } + } + +// --------------------------------------------------------------------------- +// Gets the Calendar Name from input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetCalendarNameL( const CLiwGenericParamList& aInParamList, + const TDesC8& aCmdName, + const TDesC8& aField, + TBool aPosBased, + HBufC*& aCalendarName ) + { + const TLiwGenericParam* param = NULL; + + if ( aPosBased && aInParamList.Count() > 1) + { + param = &aInParamList[1]; + } + else + { + TInt pos = 0; + param = aInParamList.FindFirst( pos, aField ); + } + + if ( param ) + { + const CLiwMap* inMap = param->Value().AsMap(); + + if(inMap) + { + TLiwVariant inParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &inParam)); + if ( inMap->FindL( KCalendarName, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + aCmdName, KCalendarName, KInvalid ); + + if ( inParam.AsDes().Length() > KMaxFileName ) + { + AppendErrorMessageL( aCmdName, KCalendarName, KInvalid ); + User::Leave(KErrArgument); + } + + if( inParam.AsDes().Length() ) + { + if ( inParam.AsDes().LocateF(':') == KErrNotFound ) + { + AppendErrorMessageL( aCmdName, KCalendarName, KInvalid ); + User::Leave(KErrArgument); + } + else + { + aCalendarName = inParam.AsDes().AllocL(); + aCalendarName->Des().Trim(); + } + } + } + CleanupStack::Pop( &inParam ); + inParam.Reset(); + } + else + { + AppendErrorMessageL( aCmdName, aField, KInvalid ); + User::Leave(KErrArgument); + } + } + } + +// --------------------------------------------------------------------------- +// Gets the Field from Map in input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetDesCFieldFromMapL( const CLiwGenericParamList& aInParamList, + const TDesC8& aCmdName, + const TDesC8& aMapName, + const TDesC8& aFieldName, + TBool aPosBased, + HBufC*& aOutputField ) + { + const TLiwGenericParam* param = NULL; + + if ( aPosBased && aInParamList.Count() > 1) + { + param = &aInParamList[1]; + } + else + { + TInt pos = 0; + param = aInParamList.FindFirst( pos, aMapName ); + } + + if ( param ) + { + const CLiwMap* inMap = param->Value().AsMap(); + + if(inMap) + { + TLiwVariant inParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &inParam)); + if ( inMap->FindL( aFieldName, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + aCmdName, aFieldName, KInvalid ); + + if ( inParam.AsDes().Length() > KMaxFileNameLength ) + { + AppendErrorMessageL( aCmdName, aFieldName, KInvalid ); + User::Leave(KErrArgument); + } + + if( inParam.AsDes().Length() ) + { + aOutputField = HBufC::NewL(inParam.AsDes().Length()); + aOutputField->Des().Copy( inParam.AsDes() ); + } + } + CleanupStack::Pop( &inParam ); + inParam.Reset(); + } + else + { + AppendErrorMessageL( aCmdName, aMapName, KInvalid ); + User::Leave(KErrArgument); + } + } + } + +// --------------------------------------------------------------------------- +// Gets the Field from Map in input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetDesC8FieldFromMapL( const CLiwGenericParamList& aInParamList, + const TDesC8& aCmdName, + const TDesC8& aMapName, + const TDesC8& aFieldName, + TBool aPosBased, + HBufC8*& aOutputField ) + { + const TLiwGenericParam* param = NULL; + + if ( aPosBased && aInParamList.Count() > 1) + { + param = &aInParamList[1]; + } + else + { + TInt pos = 0; + param = aInParamList.FindFirst( pos, aMapName ); + } + + if ( param ) + { + const CLiwMap* inMap = param->Value().AsMap(); + + if(inMap) + { + TLiwVariant inParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &inParam)); + + if ( inMap->FindL( aFieldName, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC8, + aCmdName, aFieldName, KInvalid ); + + if( inParam.AsData().Length() ) + { + aOutputField = inParam.AsData().AllocL(); + } + } + CleanupStack::Pop( &inParam ); + inParam.Reset(); + } + else + { + AppendErrorMessageL( aCmdName, aMapName, KInvalid ); + User::Leave(KErrArgument); + } + } + } + +// --------------------------------------------------------------------------- +// Extracts Entry attributes of a Calendar entry +// --------------------------------------------------------------------------- +// +CEntryAttributes* CCalendarInterface::GetAddParametersL( const CLiwGenericParamList& aInParamList, + const TDesC& aCalendarName, + TBool aPosBasedSearch ) + { + CEntryAttributes* entryAttributes = CEntryAttributes::NewL(); + + CleanupStack::PushL( entryAttributes ); + + const TLiwGenericParam* param = NULL; + + if ( aPosBasedSearch ) + { + if( aInParamList.Count() > 1 ) + param = &aInParamList[1]; + } + else + { + TInt pos = 0; + param = aInParamList.FindFirst( pos, KItem ); + } + + if ( param ) + { + const CLiwMap* inMap = param->Value().AsMap(); + if( inMap ) + { + TLiwVariant inParam; + TInt error = KErrNone; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &inParam)); + + // Applicable only for Update request + TBool isUpdate = EFalse; + TInt entryType = -1; + if ( inMap->FindL( KLocalId, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KLocalId, KInvalid ); + + //entryAttributes->SetLocalUid( TCalLocalUid(inParam.AsTUint() )); + TCalLocalUid localUid; + GetLocalUid( inParam.AsDes(), localUid ); + entryAttributes->SetLocalUid( localUid ); + isUpdate = ETrue; + } + + if ( inMap->FindL( KType, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, _L8("Entry Type"), KInvalid ); + + entryAttributes->SetTypeL( inParam.AsDes() ); + entryType = entryAttributes->EntryType(); + } + + //Adding New Entry + else if( !isUpdate ) + { + AppendErrorMessageL( KCmdAdd, KType, KMissing ); + User::Leave( KErrArgument ); + } + + //Updating Existing Entry + //Get the type of the original entry. User cannot change the type + if( isUpdate ) + { + entryType = GetEntryType( aCalendarName, entryAttributes->LocalUid() ); + if ( entryType == -1 ) + { + AppendErrorMessageL( KCmdAdd, KLocalId, KInvalid ); + User::Leave( KErrArgument ); + } + + // Leave if tring to set different entry type + if ( entryAttributes->ModifiedAttributes() & CEntryAttributes::EEntryType ) + { + TInt tmpType = entryAttributes->EntryType(); + if ( tmpType != entryType ) + { + AppendErrorMessageL( KCmdAdd, _L8("Entry Type "), KInvalid ); + User::Leave( KErrArgument ); + } + } + } + + //For Add + if ( inMap->FindL( KSummary, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KSummary, KInvalid ); + + entryAttributes->SetSummaryL( inParam.AsDes() ); + } + + if ( inMap->FindL( KDescription, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KDescription, KInvalid ); + + entryAttributes->SetDescriptionL( inParam.AsDes() ); + } + + if ( inMap->FindL( KReplication, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KReplication, KInvalid ); + + entryAttributes->SetReplicationL( inParam.AsDes() ); + } + + if ( inMap->FindL( KPriority, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTInt32, + KCmdAdd, KPriority, KInvalid ); + + error = entryAttributes->SetPriority( inParam.AsTInt32() ); + User::LeaveIfError( error ); + } + + if ( ( entryType != CCalEntry::ETodo ) && + inMap->FindL( KStartTime, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTTime, + KCmdAdd, KStartTime, KInvalid ); + + entryAttributes->SetStartTimeL( inParam.AsTTime() ); + } + + if ( ( ( entryType == CCalEntry::EAppt ) || + ( entryType == CCalEntry::ETodo ) || + ( entryType == CCalEntry::EEvent ) ) && + inMap->FindL( KEndTime, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTTime, + KCmdAdd, KEndTime, KInvalid ); + + entryAttributes->SetEndTimeL( inParam.AsTTime() ); + } + + if ( inMap->FindL( KAlarmTime, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTTime, + KCmdAdd, KAlarmTime, KInvalid ); + + entryAttributes->SetAlarm( inParam.AsTTime() ); + } + + if( ( entryType == CCalEntry::EAppt ) || + ( entryType == CCalEntry::ETodo ) ) + { + if ( inMap->FindL( KStatus, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KStatus, KInvalid ); + + entryAttributes->SetEntryStatusL( inParam.AsDes() ); + } + } + + if( entryType == CCalEntry::EAppt ) + { + // Applicable only for Update request + if ( isUpdate && inMap->FindL( KInstStartTime, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTTime, + KCmdAdd, KInstStartTime, KInvalid ); + + entryAttributes->SetInstanceStartTimeL( inParam.AsTTime() ); + } + + if ( inMap->FindL( KLocation, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KLocation, KInvalid ); + + entryAttributes->SetLocationL( inParam.AsDes() ); + } + + if ( inMap->FindL( KMethod, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KMethod, KInvalid ); + + entryAttributes->SetMethodL( inParam.AsDes() ); + } + + if ( inMap->FindL( KSeqNum, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeTInt32, + KCmdAdd, KSeqNum, KInvalid ); + + entryAttributes->SetSequenceNumber( inParam.AsTInt32() ); + } + + if ( inMap->FindL( KPhoneOwner, inParam ) ) + { + ValidateParamTypeL( inParam, LIW::EVariantTypeDesC, + KCmdAdd, KPhoneOwner, KInvalid ); + + entryAttributes->SetPhoneOwnerDataL( inParam.AsDes() ); + } + + if ( inMap->FindL( KOrganizer, inParam ) ) + { + const CLiwMap* map = inParam.AsMap(); + if ( map ) + { + TLiwVariant orgParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &orgParam)); + if ( map->FindL( KAddress, orgParam ) ) + { + CAttendeeInfo* organizer = CAttendeeInfo::NewL( orgParam.AsDes() ); + CleanupStack::PushL( organizer ); + if ( map->FindL( KCommonName, orgParam ) ) + { + ValidateParamTypeL( orgParam, LIW::EVariantTypeDesC, + KCmdAdd, KCommonName, KInvalid ); + + organizer->SetCommonNameL( orgParam.AsDes() ); + } + entryAttributes->SetOrganizerDataL( organizer ); + CleanupStack::PopAndDestroy( organizer ); + } + else + { + AppendErrorMessageL(KCmdAdd, KOrganizer, KInvalid ); + User::Leave( KErrArgument ); + } + CleanupStack::Pop( &orgParam ); + orgParam.Reset(); + } + else + { + AppendErrorMessageL(KCmdAdd, KOrganizer, KInvalid ); + User::Leave( KErrArgument ); + } + } + + if ( inMap->FindL( KAttendeeList, inParam ) ) + { + const CLiwList* obj = inParam.AsList(); + if ( obj ) + { + TInt count = obj->Count(); + for ( int index = 0; index < count; index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + obj->AtL(index, element); + const CLiwMap* map = element.AsMap(); + TLiwVariant attParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &attParam)); + if ( map && map->FindL(KAddress, attParam) ) + { + ValidateParamTypeL( attParam, LIW::EVariantTypeDesC, + KCmdAdd, KAddress, KInvalid ); + + CAttendeeInfo* attendee = CAttendeeInfo::NewL( attParam.AsDes() ); + CleanupStack::PushL( attendee ); + if ( map->FindL( KCommonName, attParam ) ) + { + ValidateParamTypeL( attParam, LIW::EVariantTypeDesC, + KCmdAdd, KCommonName, KInvalid ); + + attendee->SetCommonNameL( attParam.AsDes() ); + } + if ( map->FindL( KRole, attParam ) ) + { + ValidateParamTypeL( attParam, LIW::EVariantTypeDesC, + KCmdAdd, KRole, KInvalid ); + + attendee->SetRoleL( attParam.AsDes() ); + } + + if ( map->FindL( KStatus, attParam ) ) + { + ValidateParamTypeL( attParam, LIW::EVariantTypeDesC, + KCmdAdd, KStatus, KInvalid ); + + attendee->SetStatusL( attParam.AsDes() ); + } + + if ( map->FindL( KRsvp, attParam ) ) + { + ValidateParamTypeL( attParam, LIW::EVariantTypeTBool, + KCmdAdd, KRsvp, KInvalid ); + + attendee->SetRsvp( attParam.AsTBool() ); + } + entryAttributes->AddAttendeeL( attendee ); + CleanupStack::PopAndDestroy( attendee ); + } + else + { + AppendErrorMessageL(KCmdAdd, KAttendeeList, KInvalid); + User::Leave( KErrArgument ); + } + CleanupStack::Pop( &attParam ); + attParam.Reset(); + CleanupStack::Pop( &element ); + element.Reset(); + } + } + else + { + AppendErrorMessageL(KCmdAdd, KAttendeeList, KInvalid); + User::Leave( KErrArgument ); + } + } + + if( inMap->FindL( KRepeatDates, inParam ) ) + { + const CLiwList* obj = inParam.AsList(); + if ( obj ) + { + for ( int index = 0; index < obj->Count(); index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + obj->AtL(index, element); + + ValidateParamTypeL( element, LIW::EVariantTypeTTime, + KCmdAdd, KRepeatDates, KInvalid); + + TTime reptDate = element.AsTTime(); + entryAttributes->AddRepeatDateL( reptDate ); + CleanupStack::Pop( &element ); + element.Reset(); + } + } + else + { + AppendErrorMessageL(KCmdAdd, KRepeatDates, KInvalid); + User::Leave( KErrArgument ); + } + } + + if( inMap->FindL( KExceptionDates, inParam ) ) + { + const CLiwList* obj = inParam.AsList(); + if ( obj ) + { + for ( int index = 0; index < obj->Count(); index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + obj->AtL(index, element); + + ValidateParamTypeL( element, LIW::EVariantTypeTTime, + KCmdAdd, KExceptionDates, KInvalid ); + + TTime exDate = element.AsTTime(); + entryAttributes->AddExceptionDateL( exDate ); + CleanupStack::Pop( &element ); + element.Reset(); + } + } + else + { + inParam.Reset(); + AppendErrorMessageL( KCmdAdd, KExceptionDates, KInvalid ); + User::Leave( KErrArgument ); + } + } + + if ( inMap->FindL( KRepeatRule, inParam ) ) + { + const CLiwMap* map = inParam.AsMap(); + if ( map ) + { + CRepeatInfo* rrule = NULL; + TLiwVariant rptParam; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &rptParam)); + if ( map->FindL( KRepeatType, rptParam ) ) + { + ValidateParamTypeL( rptParam, LIW::EVariantTypeTInt32, + KCmdAdd, KRepeatType, KInvalid ); + + rrule = CRepeatInfo::NewL( rptParam.AsTInt32() ); + CleanupStack::PushL( rrule ); + } + else + { + AppendErrorMessageL( KCmdAdd, KRepeatType, KMissing ); + User::Leave( KErrArgument ); + } + + if ( map->FindL( KDaysInWeek, rptParam ) ) + { + const CLiwList* obj = rptParam.AsList(); + if ( obj ) + { + RArray < TDay > days; + for ( int index = 0; index < obj->Count(); index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + obj->AtL(index, element); + + ValidateParamTypeL( element, LIW::EVariantTypeTInt32, + KCmdAdd, KDaysInWeek, KInvalid ); + + days.Append( TDay( element.AsTInt32() ) ); + if( element.AsTInt32() < 0 || element.AsTInt32() > 6 ) + { + days.Close(); + AppendErrorMessageL( KCmdAdd, KDaysInWeek, KInvalid ); + User::Leave( KErrArgument ); + } + CleanupStack::Pop( &element ); + element.Reset(); + } + rrule->SetDaysInWeek(days); + days.Close(); + } + else + { + AppendErrorMessageL( KCmdAdd, KDaysInWeek, KInvalid ); + User::Leave( KErrArgument ); + } + } + + if ( map->FindL( KUntilDate, rptParam ) ) + { + ValidateParamTypeL( rptParam, LIW::EVariantTypeTTime, + KCmdAdd, KUntilDate, KInvalid ); + + rrule->SetUntilTimeL( rptParam.AsTTime() ); + } + + if ( map->FindL( KRStartDate, rptParam ) ) + { + ValidateParamTypeL( rptParam, LIW::EVariantTypeTTime, + KCmdAdd, _L8("RepeatRule:StartDate"), KInvalid ); + + rrule->SetStartTimeL( rptParam.AsTTime() ); + } + if ( map->FindL( KInterval, rptParam ) ) + { + ValidateParamTypeL( rptParam, LIW::EVariantTypeTInt32, + KCmdAdd, KInterval, KInvalid ); + + rrule->SetInterval( rptParam.AsTInt32() ); + } + + if ( map->FindL( KMonthDays, rptParam ) ) + { + const CLiwList* obj = rptParam.AsList(); + if ( obj ) + { + RArray < TInt > days; + for ( int index = 0; index < obj->Count(); index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + + obj->AtL(index, element); + + ValidateParamTypeL( element, LIW::EVariantTypeTInt32, + KCmdAdd, KMonthDays, KInvalid ); + + TInt mthdays = element.AsTInt32(); + if( mthdays < 0 || mthdays > 30 ) + { + days.Close(); + AppendErrorMessageL( KCmdAdd, KMonthDays, KInvalid ); + User::Leave( KErrArgument ); + } + days.Append( TDay( mthdays ) ); + CleanupStack::Pop( &element ); + element.Reset(); + } + rrule->SetMonthDates(days); + days.Close(); + } + else + { + AppendErrorMessageL( KCmdAdd, KMonthDays, KInvalid ); + User::Leave( KErrArgument ); + } + } + + if ( map->FindL( KDaysOfMonth, rptParam ) ) + { + const CLiwList* obj = rptParam.AsList(); + if ( obj ) + { + RArray monthdays; + TInt count = obj->Count(); + for ( int index = 0; index < count ; index++ ) + { + TLiwVariant element; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &element)); + obj->AtL(index, element); + const CLiwMap* map = element.AsMap(); + if( map ) + { + TLiwVariant dayno; + TLiwVariant week; + + if ( map->FindL( KDay, dayno ) && map->FindL( KWeekNum, week ) ) + { + ValidateParamTypeL( dayno, LIW::EVariantTypeTInt32, + KCmdAdd, _L8("RepeatRule:DaysOfMonth:Day"), KInvalid ); + + ValidateParamTypeL( week, LIW::EVariantTypeTInt32, + KCmdAdd, KRepeatWeekNum, KInvalid ); + + TInt weekno = week.AsTInt32(); + TInt daynum = dayno.AsTInt32(); + + if ( ( ( weekno == -1 ) || ( weekno >=1 && weekno <=4 ) ) && + ( daynum >=0 && daynum <=6 )) + { + monthdays.Append(TCalRRule::TDayOfMonth( TDay( daynum ), weekno ) ); + } + else + { + AppendErrorMessageL(KCmdAdd, KRepeatWeekNum, KInvalid); + User::Leave( KErrArgument ); + } + } + dayno.Reset(); + week.Reset(); + CleanupStack::Pop( &element ); + element.Reset(); + } + else + { + AppendErrorMessageL(KCmdAdd, KDaysOfMonth, KInvalid); + User::Leave( KErrArgument ); + } + } + rrule->SetMonthDays( monthdays ); + monthdays.Close(); + } + else + { + AppendErrorMessageL(KCmdAdd, KDaysOfMonth, KInvalid); + User::Leave( KErrArgument ); + } + } + + if ( map->FindL( KMonth, rptParam ) ) + { + ValidateParamTypeL( rptParam, LIW::EVariantTypeTInt32, + KCmdAdd, KMonth, KInvalid ); + + TInt rptmonth = rptParam.AsTInt32(); + if( rptmonth <0 || rptmonth > 11 ) + { + AppendErrorMessageL( KCmdAdd, KMonth, KInvalid ); + User::Leave( KErrArgument ); + } + rrule->SetMonth( rptmonth ); + } + entryAttributes->SetRepeatRule( rrule ); + CleanupStack::PopAndDestroy( rrule ); + CleanupStack::Pop( &rptParam ); + rptParam.Reset(); + } + else + { + AppendErrorMessageL( KCmdAdd, KRepeatRule, KInvalid ); + User::Leave( KErrArgument ); + } + + } + } + + + CleanupStack::Pop( &inParam ); + inParam.Reset(); + } + else + { + AppendErrorMessageL( KCmdAdd, KItem, KInvalid ); + User::Leave( KErrArgument ); + } + + } + else + { + AppendErrorMessageL( KCmdAdd, KItem, KMissing ); + User::Leave( KErrArgument ); + } + CleanupStack::Pop( entryAttributes ); + return entryAttributes; + } + +// --------------------------------------------------------------------------- +// Extracts Delete Filter from input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetDeleteEntryFilterL(const CLiwGenericParamList& aInParamList, + CCalendarFilter& aFilter, + const TBool aPosBased ) + { + const TLiwGenericParam* filter = NULL; + + if ( aPosBased ) + { + if ( aInParamList.Count() > 1 ) + filter = &aInParamList[1]; + } + else + { + TInt pos = 0 ; + filter = aInParamList.FindFirst( pos, KData ); + } + + if ( filter ) + { + const CLiwMap* filterMap = filter->Value().AsMap(); + if ( filterMap ) + { + TLiwVariant param; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , ¶m)); + if( filterMap->FindL( KStartRange, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdDelete, KStartRange, KInvalid ); + + aFilter.SetStartTimeL(param.AsTTime()); + } + + if( filterMap->FindL( KEndRange, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdDelete, KEndRange, KInvalid ); + + aFilter.SetEndTimeL(param.AsTTime()); + } + + if( filterMap->FindL( KDeleteAll, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTBool, + KCmdDelete, KDeleteAll, KInvalid ); + + aFilter.SetDeleteAll( param.AsTBool() ); + } + + if( filterMap->FindL( KIdList, param )) + { + const CLiwList* guidList = param.AsList(); + if ( guidList ) + { + TLiwVariant listElement; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &listElement)); + TInt count = guidList->Count(); + for(TInt index = 0; index < count; index++) + { + if ( guidList->AtL(index, listElement) ) + { + //aFilter.AddGuidL( listElement.AsData() ); + ValidateParamTypeL( listElement, LIW::EVariantTypeDesC, + KCmdDelete, KIdList, KInvalid ); + + HBufC8* globalUid = HBufC8::NewL(listElement.AsDes().Length()); + CleanupStack::PushL( globalUid ); + GetGlobalUid(listElement.AsDes(), globalUid->Des()); + aFilter.AddGuidL( globalUid->Des() ); + CleanupStack::PopAndDestroy( globalUid ); + } + } + CleanupStack::Pop( &listElement ); + listElement.Reset(); + } + else + { + AppendErrorMessageL( KCmdDelete, KIdList, KInvalid ); + User::Leave(KErrArgument); + } + } + + if( filterMap->FindL( KLocalIdList, param )) + { + const CLiwList* luidList = param.AsList(); + if ( luidList ) + { + TLiwVariant listElement; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &listElement)); + TInt count = luidList->Count(); + for(TInt index = 0; index < count; index++) + { + if ( luidList->AtL(index, listElement) ) + { + //aFilter.AddLocalUid( TCalLocalUid( listElement.AsTUint() )); + ValidateParamTypeL( listElement, LIW::EVariantTypeDesC, + KCmdDelete, KLocalIdList, KInvalid ); + + + TCalLocalUid localUid; + GetLocalUid( listElement.AsDes(), localUid ); + aFilter.AddLocalUid( localUid ); + } + } + CleanupStack::Pop( &listElement ); + listElement.Reset(); + } + else + { + AppendErrorMessageL( KCmdDelete, KLocalIdList, KInvalid ); + User::Leave(KErrArgument); + } + } + CleanupStack::Pop( ¶m ); + param.Reset(); + } + else + { + AppendErrorMessageL( KCmdDelete, KData, KInvalid ); + User::Leave(KErrArgument); + } + } + else + { + AppendErrorMessageL( KCmdDelete, KData, KMissing ); + User::Leave(KErrArgument); + } + } + +// --------------------------------------------------------------------------- +// Extracts Import input from input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetImportInputL( const CLiwGenericParamList& aInParamList, + TBool aPosBased, + HBufC8*& aInputBuffer, + TDes& importFile, + TDes8& aCalendarFormat, + TDes& aCalendarName ) + { + + //get the Input Filter Map + const TLiwGenericParam* inMap = NULL; + + if( aPosBased ) + { + if( aInParamList.Count() > 1 ) + inMap = &(aInParamList[1]);//start searching from pos and reset the pos to found at index + } + else + { + TInt pos = 0; + inMap = aInParamList.FindFirst( pos, KData ); + } + + if ( inMap ) + { + const CLiwMap * filterMap = inMap->Value().AsMap(); + + if ( filterMap ) + { + TLiwVariant value; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &value)); + + if ( filterMap->FindL( KCalendarName, value )) + { + ValidateParamTypeL( value, LIW::EVariantTypeDesC, + KCmdImport, KCalendarName, KInvalid ); + + aCalendarName.Copy( value.AsDes() ); + } + + if ( filterMap->FindL( KCalendarFormat, value )) + { + ValidateParamTypeL( value, LIW::EVariantTypeDesC, + KCmdImport, KCalendarFormat, KInvalid ); + + aCalendarFormat.Copy( value.AsDes() ); + } + else + { + AppendErrorMessageL( KCmdImport, KCalendarFormat, KMissing ); + User::Leave( KErrArgument ); + } + + if ( filterMap->FindL( KInputBuffer, value )) + { + ValidateParamTypeL( value, LIW::EVariantTypeDesC8, + KCmdImport, KInputBuffer, KInvalid ); + + aInputBuffer = value.AsData().AllocL(); + } + else if ( filterMap->FindL( KImExFileName, value )) + { + ValidateParamTypeL( value, LIW::EVariantTypeDesC, + KCmdImport, KImExFileName, KInvalid ); + + importFile.Copy( value.AsDes() ); + } + else + { + AppendErrorMessageL( KCmdImport, KImExFileName, KMissing ); + User::Leave( KErrArgument ); + } + CleanupStack::Pop( &value ); + value.Reset(); + + } + else + { + AppendErrorMessageL( KCmdImport, KData, KInvalid ); + User::Leave( KErrArgument ); + } + } + else + { + AppendErrorMessageL( KCmdImport, KData, KMissing ); + User::Leave( KErrArgument ); + } + } + +// --------------------------------------------------------------------------- +// Extracts Export input from input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetExportInputL( const CLiwGenericParamList& aInParamList, + TBool aPosBased, + CCalendarExportParams& aCalExportParams ) + { + const TLiwGenericParam* inMap = NULL; //get the Input Filter Map + + TInt pos = 0; + + if( aPosBased ) + { + if( aInParamList.Count() > 1 ) + inMap = &(aInParamList[1]); + } + else + inMap = aInParamList.FindFirst( pos, KData ); + + if( inMap ) + { + const CLiwMap *filterMap = inMap->Value().AsMap(); + + if( filterMap ) + { + TLiwVariant tLiwVariantValue; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &tLiwVariantValue)); + + if ( filterMap->FindL( KImExFileName, tLiwVariantValue )) + { + ValidateParamTypeL( tLiwVariantValue, LIW::EVariantTypeDesC, + KCmdExport, KImExFileName, KInvalid ); + + aCalExportParams.SetExportFileNameL( tLiwVariantValue.AsDes() ); + } + + + TLiwVariant tLiwVariantValueTemp; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &tLiwVariantValueTemp)); + if( filterMap->FindL( KCalendarGuidList, tLiwVariantValue ) ) + { + const CLiwList *cLiwList = tLiwVariantValue.AsList(); + + if ( cLiwList ) + { + for( TInt x = 0; x < cLiwList->Count(); ++x ) + { + cLiwList->AtL( x , tLiwVariantValueTemp ); + + ValidateParamTypeL( tLiwVariantValueTemp, LIW::EVariantTypeDesC, + KCmdExport, KCalendarGuidList, KInvalid ); + + HBufC8* globalUid = HBufC8::NewL(tLiwVariantValueTemp.AsDes().Length()); + CleanupStack::PushL( globalUid ); + GetGlobalUid(tLiwVariantValueTemp.AsDes(), globalUid->Des()); + aCalExportParams.AddGuidL( globalUid->Des() ); + CleanupStack::PopAndDestroy( globalUid ); + } + } + else + { + AppendErrorMessageL( KCmdExport, KCalendarGuidList, KInvalid ); + User::Leave( KErrArgument ); + } + + } + + if( filterMap->FindL( KCalendarLuidList, tLiwVariantValue ) ) + { + const CLiwList *cLiwListTemp = tLiwVariantValue.AsList(); + + if ( cLiwListTemp ) + { + if( cLiwListTemp->Count() && ( aCalExportParams.Params() & CCalendarExportParams::EParamsGUid ) ) + {//means the GUIDS are set so break, as both GUIDS and LUids cant be set + AppendErrorMessageL(KCmdExport, KNullDesC8,_L("Only one of IdList and LocalIdList can be given")); + User::Leave( KErrArgument ); + } + + for( TInt x = 0; x < cLiwListTemp->Count(); ++x ) + { + cLiwListTemp->AtL( x , tLiwVariantValueTemp ); + + ValidateParamTypeL( tLiwVariantValueTemp, LIW::EVariantTypeDesC, + KCmdExport, KCalendarLuidList, KInvalid ); + + TCalLocalUid localUid; + GetLocalUid( tLiwVariantValueTemp.AsDes(), localUid ); + aCalExportParams.AddLocalUid( localUid ); + } + } + else + { + AppendErrorMessageL( KCmdExport, KCalendarLuidList, KInvalid ); + User::Leave( KErrArgument ); + } + } + + CleanupStack::Pop( &tLiwVariantValueTemp ); + tLiwVariantValueTemp.Reset(); + CleanupStack::Pop( &tLiwVariantValue ); + tLiwVariantValue.Reset(); + } + else + { + AppendErrorMessageL( KCmdExport, KData, KInvalid ); + User::Leave( KErrArgument ); + } + } + else + { + AppendErrorMessageL( KCmdExport, KData, KMissing ); + User::Leave( KErrArgument ); + } + } + +// --------------------------------------------------------------------------- +// Extracts Change Notification filter from input param list +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetNotificationFilterL(const CLiwGenericParamList& aInParamList, + CCalendarFilter& aFilter, + const TBool aPosBased ) + { + const TLiwGenericParam* filter = NULL; + + if ( aPosBased ) + { + if ( aInParamList.Count() > 1 ) + filter = &aInParamList[1]; + } + else + { + TInt pos = 0 ; + filter = aInParamList.FindFirst( pos, KFilter ); + } + + if ( filter ) + { + const CLiwMap* filterMap = filter->Value().AsMap(); + if ( filterMap ) + { + TLiwVariant param; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , ¶m)); + if( filterMap->FindL( KStartRange, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdReqNot, KStartRange, KInvalid ); + + aFilter.SetStartTimeL(param.AsTTime()); + } + + if( filterMap->FindL( KEndRange, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTTime, + KCmdReqNot, KEndRange, KInvalid ); + + aFilter.SetEndTimeL(param.AsTTime()); + } + + if( filterMap->FindL( KIncludeUndatedTodos, param )) + { + ValidateParamTypeL( param, LIW::EVariantTypeTBool, + KCmdReqNot, KIncludeUndatedTodos, KInvalid ); + + aFilter.SetIncludeUnDateToDo( param.AsTBool() ); + } + + if( filterMap->FindL( KLocalIdList, param )) + { + const CLiwList* luidList = param.AsList(); + if ( luidList ) + { + TLiwVariant listElement; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &listElement)); + TInt count = luidList->Count(); + for(TInt index = 0; index < count; index++) + { + if ( luidList->AtL(index, listElement) ) + { + TCalLocalUid localUid; + + ValidateParamTypeL( listElement, LIW::EVariantTypeDesC, + KCmdReqNot, KLocalIdList, KInvalid ); + + GetLocalUid( listElement.AsDes(), localUid ); + aFilter.AddLocalUid( localUid ); + } + } + CleanupStack::Pop( &listElement ); + listElement.Reset(); + } + else + { + AppendErrorMessageL( KCmdReqNot, KLocalIdList, KInvalid ); + User::Leave(KErrArgument); + } + } + CleanupStack::Pop( ¶m ); + param.Reset(); + } + else + { + AppendErrorMessageL( KCmdReqNot, KFilter, KInvalid ); + User::Leave(KErrArgument); + } + } + } + + +// --------------------------------------------------------------------------- +// Extracts LocalUid as TCalLocalUid from input Uid String +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid ) + { + aOutLocalUid = 0; + /*if( aLocalUid.Length() ) + { + TInt sepPos = aLocalUid.Locate( KUidSeparator ); + TPtrC temp; + if( sepPos == KErrNotFound ) + { + temp.Set(aLocalUid.Mid(0)); + } + else + { + temp.Set(aLocalUid.Mid(0, sepPos)); + } + }*/ + TLex lex(aLocalUid); + TInt32 num; + + if(lex.Val(num) == KErrNone) + aOutLocalUid = TCalLocalUid(num); + + } + +// --------------------------------------------------------------------------- +// Extracts GlobalUid as 8-bit string from input Uid String +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetGlobalUid( const TDesC& aGlobalUid, TPtr8 aOutGlobalUid ) + { + if( aGlobalUid.Length() ) + { + /*TInt sepPos = aGlobalUid.Locate( KUidSeparator ); + + if( sepPos == KErrNotFound ) + { + aOutGlobalUid.Copy( aGlobalUid.Mid(0) ); + } + else + { + aOutGlobalUid.Copy( aGlobalUid.Mid( sepPos + 1 ) ); + }*/ + aOutGlobalUid.Copy( aGlobalUid ); + } + + } + +// --------------------------------------------------------------------------- +// ErrCode Conversion +// --------------------------------------------------------------------------- +// +TInt32 CCalendarInterface::ErrCodeConversion(TInt code) + { + TInt32 err; + switch (code) + { + case KErrCancel: + // Returning KErrNone incase of KErrCancel + case KErrNone: + err= SErrNone; + break; + + case KErrNotFound: + err= SErrNotFound; + break; + + case KErrNoMemory: + err = SErrNoMemory; + break; + + case KErrInUse: + err = SErrServiceInUse; + break; + + case KErrNotSupported: + err = SErrServiceNotSupported; + break; + + case KErrBadName: + err = SErrBadArgumentType; + break; + + case KErrArgument: + err = SErrInvalidServiceArgument; + break; + + case KErrAccessDenied: + err = SErrAccessDenied; + break; + + case KErrPathNotFound: + err = SErrPathNotFound; + break; + + case KErrAlreadyExists: + err = SErrEntryExists; + break; + + default : + err = SErrGeneralError; + break; + } + + return err; + + } + +// --------------------------------------------------------------------------- +// Validate the type of the input param with the expected type +// --------------------------------------------------------------------------- +// +void CCalendarInterface::ValidateParamTypeL( TLiwVariant& aParam, + LIW::TVariantTypeId aExpectedtype, + const TDesC8& aCmdName, + const TDesC8& aParameter, + const TDesC& aMessage ) + { + if( aParam.TypeId() != aExpectedtype ) + { + AppendErrorMessageL(aCmdName, aParameter, aMessage); + aParam.Reset(); + User::Leave(KErrArgument); + } + } + +// --------------------------------------------------------------------------- +// Append Error Message +// --------------------------------------------------------------------------- +// +void CCalendarInterface::AppendErrorMessageL( const TDesC8& aCmdName, const TDesC8& aParameter, const TDesC& aMessage ) + { + iErrorMessage = HBufC::NewL( KMaxErrorMessageLength ); + TPtr tmpMsgPtr = iErrorMessage->Des(); + tmpMsgPtr.Copy(KDomainName); + + HBufC* temp = HBufC::NewL( KMaxErrorMessageLength ); + + if ( aCmdName.Length() ) + { + tmpMsgPtr.Append( KErrorMsgSeparator ); + temp->Des().Copy( aCmdName ); + tmpMsgPtr.Append( temp->Des() ); + } + + tmpMsgPtr.Append(KErrorMsgSeparator); + + if ( aParameter.Length() ) + { + temp->Des().Copy(aParameter); + tmpMsgPtr.Append(temp->Des()); + } + + if ( aMessage.Length() ) + { + tmpMsgPtr.Append( aMessage ); + } + + delete temp; + } + +// --------------------------------------------------------------------------- +// Set Import output to output parameter +// --------------------------------------------------------------------------- +// +void CCalendarInterface::SetImportOutputL( RPointerArray& aOutputUIDSet, CLiwGenericParamList& aOutParamList ) + { + TInt arrCount = aOutputUIDSet.Count(); + + //List of Maps + CLiwDefaultList *uIDList = CLiwDefaultList::NewL(); + + CleanupClosePushL( *uIDList ); + + for( TInt index = 0; index < arrCount; ++index ) + { + TLiwVariant liwVariant; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &liwVariant)); + + GetTLiwVariantForUIDSetL( liwVariant, aOutputUIDSet[ index ] ); + + uIDList->AppendL( liwVariant ); + + CleanupStack::Pop( &liwVariant ); + liwVariant.Reset(); + } + + //Iterator over List of Maps + CIterableUIDMapList *outputIterableList = CIterableUIDMapList::NewL( uIDList ); + + CleanupClosePushL( *outputIterableList ); + // Appending the Iteratot over List of Maps to the outParamList CLiwGenericParamList + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( outputIterableList ) ) ); + + CleanupStack::PopAndDestroy( outputIterableList );//doubt check at debugging + + CleanupStack::Pop( uIDList ); + } + +// --------------------------------------------------------------------------- +// Set Change Notification output to output parameter +// --------------------------------------------------------------------------- +// +void CCalendarInterface::SetNotifyOutputL( RArray& aOutputChangeSet, CLiwGenericParamList& aOutParamList ) + { + TInt arrCount = aOutputChangeSet.Count(); + + //List of Maps + CLiwDefaultList *changeList = CLiwDefaultList::NewL(); + + CleanupClosePushL( *changeList ); + + for( TInt index = 0; index < arrCount; ++index ) + { + TLiwVariant liwVariant; + CleanupStack::PushL( TCleanupItem(TLiwVariant::VariantCleanup , &liwVariant)); + + GetTLiwVariantForCalChangeEntryL( liwVariant, aOutputChangeSet[index] ); + + changeList->AppendL( liwVariant ); + + CleanupStack::Pop( &liwVariant ); + liwVariant.Reset(); + } + + //Iterator over List of Maps + CIterableUIDMapList *outputIterableList = CIterableUIDMapList::NewL( changeList ); + CleanupStack::Pop( changeList ); + CleanupClosePushL( *outputIterableList ); + + // Appending the Iteratot over List of Maps to the outParamList CLiwGenericParamList + aOutParamList.AppendL( TLiwGenericParam( KReturnValue, TLiwVariant( outputIterableList ) ) ); + + CleanupStack::PopAndDestroy( outputIterableList ); + + } + +// --------------------------------------------------------------------------- +// Set GlobalUid/LocalUid to the LiwVariant +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetTLiwVariantForUIDSetL( TLiwVariant& aValue, TUIDSet* aUIDSet ) + { + HBufC* globalUid = HBufC::NewL( aUIDSet->iGlobalUID->Length() + 1 ); + CleanupStack::PushL( globalUid ); + globalUid->Des().Copy( aUIDSet->iGlobalUID->Des() ); + aValue.SetL( TLiwVariant(*globalUid)); + CleanupStack::PopAndDestroy( globalUid ); + } + +// --------------------------------------------------------------------------- +// Set Change type to the LiwVariant +// --------------------------------------------------------------------------- +// +void CCalendarInterface::GetTLiwVariantForCalChangeEntryL( TLiwVariant& aValue, TCalChangeEntry& aChangeEntry ) + { + CLiwDefaultMap* uIDMap = CLiwDefaultMap::NewL(); + + CleanupClosePushL( *uIDMap ); + + TBuf<20> localUid; + + localUid.Num( TInt64(aChangeEntry.iEntryId )); + + uIDMap->InsertL( KLocalId, TLiwVariant( localUid ) ); + + uIDMap->InsertL( KChangeType, TLiwVariant( CCalendarInterface::GetChangeType( aChangeEntry.iChangeType ) ) ); + + aValue.SetL( uIDMap ); + + CleanupStack::PopAndDestroy( uIDMap ); + + } + +// --------------------------------------------------------------------------- +// Cleanup function for an CIterableCalEntryList +// --------------------------------------------------------------------------- +// +void CCalendarInterface::CleanupIterableCalEntry(void* aIterEntryList) + { + CIterableCalEntryList* iterEntryList = static_cast(aIterEntryList); + if ( iterEntryList ) + { + iterEntryList->DecRef(); + } + } + +// --------------------------------------------------------------------------- +// Returns Day of Month of repeat rule as LiwVariant Map. Caller takes the ownership of map +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CCalendarInterface::GetDayOfMonthL( const TCalRRule::TDayOfMonth& aDayOfMonth ) + { + CLiwDefaultMap* dayMap = CLiwDefaultMap::NewL(); + CleanupClosePushL( *dayMap ); + + dayMap->InsertL( KDay, TLiwVariant( TInt32( aDayOfMonth.Day() ) )); + dayMap->InsertL( KWeekNum, TLiwVariant( TInt32( aDayOfMonth.WeekInMonth() ) )); + + CleanupStack::Pop( dayMap ); + return dayMap; + } + +// --------------------------------------------------------------------------- +// Returns CalUser as LiwVariant Map. Caller takes the ownership of map +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CCalendarInterface::GetCalUserL( CCalUser* aCalUser, TBool aAttendee ) + { + CLiwDefaultMap* userMap = CLiwDefaultMap::NewL(); + CleanupClosePushL( *userMap ); + + userMap->InsertL( KCommonName, TLiwVariant( aCalUser->CommonName() ) ); + userMap->InsertL( KAddress, TLiwVariant( aCalUser->Address() ) ); + + if ( aAttendee ) + { + userMap->InsertL( KRole, TLiwVariant( CCalendarInterface::GetAttendeeRoleL(((CCalAttendee*)aCalUser)->RoleL() ) )); + userMap->InsertL( KStatus, TLiwVariant( CCalendarInterface::GetAttendeeStatusL(((CCalAttendee*)aCalUser)->StatusL() ) )); + userMap->InsertL( KRsvp, TLiwVariant( ((CCalAttendee*)aCalUser)->ResponseRequested() ) ); + } + + CleanupStack::Pop( userMap ); + return userMap; + } + +// --------------------------------------------------------------------------- +// Returns array of CalTime as LiwVariant List. Caller takes the ownership of list +// --------------------------------------------------------------------------- +// +CLiwDefaultList* CCalendarInterface::GetDatesListL( RArray& aDates ) + { + TInt count = aDates.Count(); + + CLiwDefaultList* dateList = CLiwDefaultList::NewL(); + CleanupClosePushL( *dateList ); + + for ( TInt index = 0 ; index < count; index++ ) + { + dateList->AppendL( aDates[index].TimeUtcL() ); + } + + CleanupStack::Pop( dateList ); + return dateList; + } + +// --------------------------------------------------------------------------- +// Returns RepeatRule as LiwVariant Map. Caller takes the ownership of map +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CCalendarInterface::GetRRMapL( const TCalRRule& repeatRule ) + { + TCalRRule::TType rrType = repeatRule.Type(); + + if ( rrType == TCalRRule::EInvalid ) + return NULL; + + CLiwDefaultMap* rrMap = CLiwDefaultMap::NewL(); + + CleanupClosePushL( *rrMap ); + + rrMap->InsertL( KRepeatType, TLiwVariant( TInt32( rrType ) )); + + rrMap->InsertL( KUntilDate, TLiwVariant( repeatRule.Until().TimeUtcL() )); + + rrMap->InsertL( KInterval, TLiwVariant( TInt32( repeatRule.Interval() ))); + + rrMap->InsertL( KRStartDate, TLiwVariant( repeatRule.DtStart().TimeUtcL() )); + + if ( rrType == TCalRRule::EWeekly ) + { + RArray dayArray; + repeatRule.GetByDayL( dayArray ); + + CLiwDefaultList* dayList = CLiwDefaultList::NewL(); + CleanupClosePushL( *dayList ); + + TInt count = dayArray.Count(); + for ( TInt index = 0 ; index < count; index++ ) + { + dayList->AppendL( TInt32( dayArray[index] )); + } + + rrMap->InsertL( KDaysInWeek, TLiwVariant( dayList )); + + CleanupStack::PopAndDestroy( dayList ); + + dayArray.Reset(); + } + else if ( rrType == TCalRRule::EMonthly ) + { + RArray monthDays; + repeatRule.GetByMonthDayL( monthDays ); + TInt count = monthDays.Count(); + if ( count > 0 ) + { + // + CLiwDefaultList* dayList = CLiwDefaultList::NewL(); + CleanupClosePushL( *dayList ); + + for ( TInt index = 0 ; index < count; index++ ) + { + dayList->AppendL( TInt32(monthDays[index] )); + } + + rrMap->InsertL( KMonthDays, TLiwVariant( dayList )); + + CleanupStack::PopAndDestroy( dayList ); + + + } + else + { + RArray< TCalRRule::TDayOfMonth > daysOfMonth; + repeatRule.GetByDayL( daysOfMonth ); + count = daysOfMonth.Count(); + if ( count > 0 ) + { + CLiwDefaultList* dayList = CLiwDefaultList::NewL(); + CleanupClosePushL( *dayList ); + + for ( TInt index = 0; index < count; index++ ) + { + CLiwDefaultMap* dayOfMonthMap = CCalendarInterface::GetDayOfMonthL( daysOfMonth[index] ); + dayList->AppendL( TLiwVariant ( dayOfMonthMap ) ); + dayOfMonthMap->DecRef(); + } + + rrMap->InsertL( KDaysOfMonth, TLiwVariant( dayList )); + + CleanupStack::PopAndDestroy( dayList ); + + } + daysOfMonth.Reset(); + } + monthDays.Reset(); + } + else if ( rrType == TCalRRule::EYearly ) + { + RArray monthArray; + repeatRule.GetByMonthL( monthArray ); + + if ( monthArray.Count() > 0 ) + { + rrMap->InsertL( KMonth, TLiwVariant( TInt32( monthArray[0] ) )); + } + monthArray.Reset(); + + + RArray< TCalRRule::TDayOfMonth > daysOfMonth; + repeatRule.GetByDayL( daysOfMonth ); + TInt count = daysOfMonth.Count(); + if ( count > 0 ) + { + CLiwDefaultList* dayList = CLiwDefaultList::NewL(); + CleanupClosePushL( *dayList ); + + for ( TInt index = 0; index < count; index++ ) + { + CLiwDefaultMap* dayOfMonthMap = CCalendarInterface::GetDayOfMonthL( daysOfMonth[index] ); + dayList->AppendL( TLiwVariant ( dayOfMonthMap ) ); + dayOfMonthMap->DecRef(); + } + + rrMap->InsertL( KDaysOfMonth, TLiwVariant( dayList )); + + CleanupStack::PopAndDestroy( dayList ); + + } + daysOfMonth.Reset(); + + } + + CleanupStack::Pop( rrMap ); + + return rrMap; + } + + +// --------------------------------------------------------------------------- +// Returns string literal for the given Entry Type +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetEntryTypeL( const CCalEntry::TType aType ) + { + TPtrC retValue; + + if ( aType == CCalEntry::EAppt ) + retValue.Set( KEntryAppt ); + + else if ( aType == CCalEntry::ETodo ) + retValue.Set( KEntryTodo ); + + else if ( aType == CCalEntry::EEvent ) + retValue.Set( KEntryEvent ); + + else if ( aType == CCalEntry::EReminder ) + retValue.Set( KEntryReminder ); + + else if ( aType == CCalEntry::EAnniv ) + retValue.Set( KEntryAnniv ); + + else + User::Leave(KErrArgument); + + return retValue; + + } + +// --------------------------------------------------------------------------- +// Returns string literal for the given Entry Replication status +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetReplicationL( const CCalEntry::TReplicationStatus aType ) + { + TPtrC retValue; + + if ( aType == CCalEntry::EPrivate ) + retValue.Set( KReplPrivate ); + + else if ( aType == CCalEntry::ERestricted ) + retValue.Set( KReplRest ); + + else + retValue.Set( KReplOpen ); + + return retValue; + + } + +// --------------------------------------------------------------------------- +// Returns string literal for Change Types +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetChangeType( const MCalChangeCallBack2::TChangeType aType ) + { + TPtrC retValue; + + if ( aType == MCalChangeCallBack2::EChangeAdd ) + retValue.Set( KChangeAdd ); + + else if ( aType == MCalChangeCallBack2::EChangeDelete ) + retValue.Set( KChangeDelete ); + + else if ( aType == MCalChangeCallBack2::EChangeModify ) + retValue.Set( KChangeModify ); + + else + retValue.Set( KChangeUndefined ); + + return retValue; + + } + +// --------------------------------------------------------------------------- +// Returns string literal for Entry Status +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetStatusL( const CCalEntry::TStatus aStatus ) + { + TPtrC retValue; + + if ( aStatus == CCalEntry::ETentative ) + retValue.Set( KStatusTentative ); + + else if ( aStatus == CCalEntry::EConfirmed ) + retValue.Set( KStatusConfirmed ); + + else if ( aStatus == CCalEntry::ECancelled ) + retValue.Set( KStatusCancelled ); + + else if ( aStatus == CCalEntry::ETodoNeedsAction ) + retValue.Set( KStatusTodoNeedsAction ); + + else if ( aStatus == CCalEntry::ETodoCompleted ) + retValue.Set( KStatusTodoCompleted ); + + else if ( aStatus == CCalEntry::ETodoInProcess ) + retValue.Set( KStatusTodoInProcess ); + + else + retValue.Set( KNullStatus ); + + return retValue; + } + +// --------------------------------------------------------------------------- +// Returns string literal for Attendee Status +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetAttendeeStatusL( const CCalAttendee::TCalStatus aStatus ) + { + TPtrC retValue; + + if ( aStatus == CCalAttendee::EAccepted ) + retValue.Set( KAttStatusAccepted ); + + else if ( aStatus == CCalAttendee::ETentative ) + retValue.Set( KAttStatusTentative ); + + else if ( aStatus == CCalAttendee::EConfirmed ) + retValue.Set( KAttStatusConfirmed ); + + else if ( aStatus == CCalAttendee::EDeclined ) + retValue.Set( KAttStatusDeclined ); + + else if ( aStatus == CCalAttendee::ECompleted ) + retValue.Set( KAttStatusCompleted ); + + else if ( aStatus == CCalAttendee::EDelegated ) + retValue.Set( KAttStatusDelegated ); + + else if ( aStatus == CCalAttendee::EInProcess ) + retValue.Set( KAttStatusInProcess ); + + else + retValue.Set( KAttStatusNeedsAction ); + + return retValue; + } + +// --------------------------------------------------------------------------- +// Get string literal for Attendee Role +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetAttendeeRoleL( const CCalAttendee::TCalRole aRole ) + { + TPtrC retValue; + + if ( aRole == CCalAttendee::EOptParticipant ) + retValue.Set( KAttRoleOptParticipant ); + + else if ( aRole == CCalAttendee::ENonParticipant ) + retValue.Set( KAttRoleNonParticipant ); + + else if ( aRole == CCalAttendee::EChair ) + retValue.Set( KAttRoleChair ); + + else + retValue.Set( KAttRoleReqParticipant ); + + return retValue; + } + +// --------------------------------------------------------------------------- +// Return string literal for Entry Method +// --------------------------------------------------------------------------- +// +TPtrC CCalendarInterface::GetMethodL( const CCalEntry::TMethod aMethod ) + { + TPtrC retValue; + + if ( aMethod == CCalEntry::EMethodPublish ) + retValue.Set( KMethodPublish ); + + else if ( aMethod == CCalEntry::EMethodRequest) + retValue.Set( KMethodRequest ); + + else if ( aMethod == CCalEntry::EMethodReply) + retValue.Set( KMethodReply ); + + else if ( aMethod == CCalEntry::EMethodAdd ) + retValue.Set( KMethodAdd ); + + else if ( aMethod == CCalEntry::EMethodCancel ) + retValue.Set( KMethodCancel ); + + else if ( aMethod == CCalEntry::EMethodRefresh ) + retValue.Set( KMethodRefresh ); + + else if ( aMethod == CCalEntry::EMethodCounter ) + retValue.Set( KMethodCounter ); + + else if ( aMethod == CCalEntry::EMethodDeclineCounter ) + retValue.Set( KMethodDecCounter ); + + else + retValue.Set( KMethodNone ); + + return retValue; + } + +// --------------------------------------------------------------------------- +// Return string literal for Entry Method +// --------------------------------------------------------------------------- +// +void CCalendarInterface::RemoveCalEntryListFromArray( CIterableCalEntryList* aCalEntryList ) + { + TInt count = iArrayCalEntryList.Count(); + for(TInt index = 0; index < count; index++ ) + { + if ( iArrayCalEntryList[index] == aCalEntryList ) + { + iArrayCalEntryList.Remove( index ); + break; + } + } + + iArrayCalEntryList.Compress(); + } + +// --------------------------------------------------------------------------- +// Return Entry Type for given LocalUid +// --------------------------------------------------------------------------- +// +TInt CCalendarInterface::GetEntryType( const TDesC& aCalendarName, TCalLocalUid aLocalUid ) + { + TInt entryType = -1; + RPointerArray entryArray; + iCalService->GetListL( aCalendarName, aLocalUid, entryArray); + if( entryArray.Count() ) + { + entryType = entryArray[0]->EntryTypeL(); + } + entryArray.ResetAndDestroy(); + return entryType; + } + +// --------------------------------------------------------------------------- +// Check if given calendar is in use by other resources +// --------------------------------------------------------------------------- +// +TBool CCalendarInterface::CheckCalendarInUse( const TDesC& aCalendarName ) + { + TBool retValue = EFalse; + TInt count = iArrayCalEntryList.Count(); + for(TInt index = 0; index < count; index++ ) + { + if ( aCalendarName.CompareF( iArrayCalEntryList[index]->CalendarName() ) == 0 ) + { + retValue = ETrue; + break; + } + } + return retValue; + }