diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/agnadapter/src.s60/cpimeventadaptermanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/pim/agnadapter/src.s60/cpimeventadaptermanager.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,429 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "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: Base class for the Agenda Model event adapter managers + * +*/ + + +// CLASS HEADER +#include "cpimeventadaptermanager.h" +#include "logger.h" + +// INTERNAL INCLUDES +#include "mpimitem.h" + +// ----------------------------------------------------------------------------- +// CPIMApptAdapterManager::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CPIMEventAdapterManager::ConstructL(const TDesC& aListName) +{ + JELOG2(EPim); + iListName = aListName.AllocL(); +} + +// Destructor +CPIMEventAdapterManager::~CPIMEventAdapterManager() +{ + JELOG2(EPim); + delete iRepeatRuleFieldArray; + delete iRepeatRuleFieldArrayEmpty; + delete iRepeatRuleIntervalArray; + delete iRepeatRuleIntervalArrayEmpty; + delete iEventAttributeArray; + delete iListName; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedRepeatRuleFields +// Provides the supported repeat rule fields for a given frequency. +// Returns: Supported repeat rule fields for \a aFrequency. If no +// fields are supported for the frequency, an empty array is returned. +// ----------------------------------------------------------------------------- +// +const CArrayFix& +CPIMEventAdapterManager::GetSupportedRepeatRuleFieldsL( + const TPIMRepeatRuleFrequency& aFrequency) +{ + JELOG2(EPim); + const CArrayFix* retVal = NULL; + + switch (aFrequency) + { + case EPIMRepeatRuleDaily: + case EPIMRepeatRuleMonthly: + case EPIMRepeatRuleYearly: + { + // Return a one item array with the item frequency + if (!iRepeatRuleFieldArrayEmpty) + { + iRepeatRuleFieldArrayEmpty + = new(ELeave) CArrayFixFlat (1); + iRepeatRuleFieldArrayEmpty->AppendL(EPIMRepeatRuleFrequency); + } + retVal = iRepeatRuleFieldArrayEmpty; + break; + } + case EPIMRepeatRuleWeekly: + { + if (!iRepeatRuleFieldArray) + { + iRepeatRuleFieldArray + = new(ELeave) CArrayFixFlat (KPIMSupportedRepeatRuleFieldsCount); + + iRepeatRuleFieldArray->AppendL(KPIMSupportedRepeatRuleFields, + KPIMSupportedRepeatRuleFieldsCount); + } + retVal = iRepeatRuleFieldArray; + break; + } + default: + { + User::Leave(KErrArgument); // Field was not a valid field + } + } + + return *retVal; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedIntervals +// Provides the supported interval values for given frequency. +// Returns: Supported interval values for given frequency. If the +// interval field is not supported for given frequency, +// an empty array is returned. +// ----------------------------------------------------------------------------- +// +const CArrayFix& CPIMEventAdapterManager::GetSupportedIntervalsL( + const TPIMRepeatRuleFrequency& aFrequency) +{ + JELOG2(EPim); + const CArrayFix* retVal = NULL; + + switch (aFrequency) + { + case EPIMRepeatRuleDaily: + case EPIMRepeatRuleMonthly: + case EPIMRepeatRuleYearly: + { + // Return an empty array indicating no supported fields + if (!iRepeatRuleIntervalArrayEmpty) + { + iRepeatRuleIntervalArrayEmpty + = new(ELeave) CArrayFixFlat (1); + } + retVal = iRepeatRuleIntervalArrayEmpty; + break; + } + case EPIMRepeatRuleWeekly: + { + if (!iRepeatRuleIntervalArray) + { + iRepeatRuleIntervalArray + = new(ELeave) CArrayFixFlat (KPIMSupportedRepeatRuleIntervalsCount); + + iRepeatRuleIntervalArray->AppendL(KPIMSupportedRepeatRuleIntervals, + KPIMSupportedRepeatRuleIntervalsCount); + } + retVal = iRepeatRuleIntervalArray; + break; + } + default: + { + User::Leave(KErrArgument); // Field was not a valid field + } + } + + return *retVal; +} + +const TDesC& CPIMEventAdapterManager::ListNameL() +{ + JELOG2(EPim); + return *iListName; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::MaxCategories +// Returns: The maximum number of categories that this list can have. +// ----------------------------------------------------------------------------- +// + +TInt CPIMEventAdapterManager::MaxCategories() +{ + JELOG2(EPim); + return 0; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::IsSupportedField +// Returns: ETrue if supported in this list, EFalse if not supported or invalid. +// ----------------------------------------------------------------------------- +// + +TBool CPIMEventAdapterManager::IsSupportedField(TPIMField aField) // The field to check +{ + JELOG2(EPim); + TInt fieldFinder; + TInt fetchIndex = 0; + TKeyArrayFix key(0, ECmpTInt); + fieldFinder = iSupportedFields->Find(aField, key, fetchIndex); + if (fieldFinder != 0) // 0 means that the element was found + { + return EFalse; + } + return ETrue; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedFieldsL +// Returns: An int array containing all fields supported by this list. +// ----------------------------------------------------------------------------- +// + +const CArrayFix& CPIMEventAdapterManager::GetSupportedFieldsL() +{ + JELOG2(EPim); + return *iSupportedFields; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::IsSupportedAttribute +// Returns: EFalse, as there are no supported attributes in Event list. +// ----------------------------------------------------------------------------- +// + +TBool CPIMEventAdapterManager::IsSupportedAttribute(TPIMField /* aField */, // The field to check the supported attribute from + TPIMAttribute /* aAttribute */) // The attribute to check +{ + JELOG2(EPim); + return EFalse; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedAttributesL +// Returns: An empty array meaning no supported attributes. +// ----------------------------------------------------------------------------- +// + +const CArrayFix& +CPIMEventAdapterManager::GetSupportedAttributesL(TPIMField aField) // The field to check the supported attributes from +{ + JELOG2(EPim); + if (!IsSupportedField(aField)) + { + User::Leave(KErrArgument); // Field was not a valid field + } + + if (!iEventAttributeArray) + { + iEventAttributeArray = new(ELeave) CArrayFixFlat (1); + } + return *iEventAttributeArray; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedAttributesCombinedL +// Returns: An integer holding the combination of all attributes +// supported for aField (KPIMAttrNone meaning no supported attributes). +// ----------------------------------------------------------------------------- + +TPIMAttribute CPIMEventAdapterManager::GetSupportedAttributesCombinedL( + TPIMField aField) // The field to check the supported attributes from +{ + JELOG2(EPim); + if (!IsSupportedField(aField)) + { + User::Leave(KErrArgument); // Field was not a valid field + } + + return KPIMAttrNone; +} + +TPIMAttribute CPIMEventAdapterManager::GetAllSupportedAttributesCombined() +{ + JELOG2(EPim); + return KPIMAttrNone; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::IsSupportedArrayElement +// Returns: EFalse, as there are no supported array elements in ToDo list. +// ----------------------------------------------------------------------------- +// + +TBool CPIMEventAdapterManager::IsSupportedArrayElement( + TPIMField /* aStringArrayField */, // The field where array element belongs + TPIMArrayElement /* aArrayElement */) // The array element to check +{ + JELOG2(EPim); + return EFalse; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::GetSupportedArrayElementsL +// Returns: An integer array containing all of the supported elements of a +// string array for the given field. +// ----------------------------------------------------------------------------- +// + +const CArrayFix& +CPIMEventAdapterManager::GetSupportedArrayElementsL(TPIMField /* aField */) // The field to check the supported array elements +{ + JELOG2(EPim); + User::Leave(KErrArgument); // No array elements in Event list. + // Even this method leaves always, the compiler requires it to return an + // array. + // The next line is only because of that, and actually it is never executed. + const CArrayFix* temp = NULL; + return *temp; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::MaxValues +// Returns: Number of values supported for the field +// -1 : The field supports having an unlimited number of values in it. +// 0 : The field is not supported by this list. +// ----------------------------------------------------------------------------- +// + +TInt CPIMEventAdapterManager::MaxValues(TPIMField aField) // The field to check for multiple value support +{ + JELOG2(EPim); + if (IsSupportedField(aField)) + { + return 1; // Only one value is supported for any valid Event field + } + else + { + return 0; + } +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::StringArraySizeL +// Returns: Int the size of the array. +// ----------------------------------------------------------------------------- +// + +TInt CPIMEventAdapterManager::StringArraySizeL(TPIMField /* aStringArrayField */) // The field to check the array size +{ + JELOG2(EPim); + User::Leave(KErrArgument); + // Even this method leaves always, the compiler requires it to return an + // array. + // The next line is only because of that, and actually it is never executed. + return 0; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::ItemOrder +// Returns: pointer to a function which implements an algorithm that +// determines the order of two items. +// ----------------------------------------------------------------------------- +// + +TPIMItemComparisonFunc CPIMEventAdapterManager::ItemOrder() +{ + JELOG2(EPim); + return ItemComparisonFunc; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::ItemComparisonFunc +// Compares two MPIMItemData objects. The comparision is based primarily on the +// start times, and secondary on the summary strings (if start times are equal). +// Returns: < 0: aFirst < aSecond +// 0: aFirst == aSecond +// > 0: aFirst > aSecond +// ----------------------------------------------------------------------------- +// +TInt CPIMEventAdapterManager::ItemComparisonFunc(const MPIMItem& aFirst, + const MPIMItem& aSecond) +{ + JELOG2(EPim); + TInt retVal = 0; + TRAPD(err, retVal = ItemComparisonFuncL(aFirst, aSecond)); + if (err != KErrNone) + { + // The comparison function does not actually leave as it is used with + // correct PIM field parameters, so this assert here is just for debug + __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory, EPIMPanicGeneral)); + } + return retVal; +} + +// ----------------------------------------------------------------------------- +// CPIMEventAdapterManager::ItemComparisonFuncL +// Compares two MPIMItemData objects. The comparision is based primarily on the +// start times, and secondary on the summary strings (if start times are equal). +// Returns: < 0: aFirst < aSecond +// 0: aFirst == aSecond +// > 0: aFirst > aSecond +// ----------------------------------------------------------------------------- +// +TInt CPIMEventAdapterManager::ItemComparisonFuncL(const MPIMItem& aFirst, + const MPIMItem& aSecond) +{ + JELOG2(EPim); + TInt firstPresent = aFirst.CountValuesL(EPIMEventStart); + TInt secondPresent = aSecond.CountValuesL(EPIMEventStart); + + if ((firstPresent == 0) ^(secondPresent == 0)) + // Only one of the fields is present + { + return secondPresent - firstPresent; + } + + else if (firstPresent > 0 && secondPresent > 0) + // Both fields are present + { + const TPIMDate dateFirst = aFirst.GetDateL(EPIMEventStart, 0); + const TPIMDate dateSecond = aSecond.GetDateL(EPIMEventStart, 0); + + if (dateFirst < dateSecond) + { + return -1; + } + else if (dateFirst > dateSecond) + { + return 1; + } + } + + // In this point either none of the items have start time field, or + // the other possibility is that the start time fields are exactly equal. + // Continue the comparision based on the 2nd criteria, the summary field. + firstPresent = aFirst.CountValuesL(EPIMEventSummary); + secondPresent = aSecond.CountValuesL(EPIMEventSummary); + + if ((firstPresent == 0) ^(secondPresent == 0)) // xor + { + // Only one of the fields is present + return secondPresent - firstPresent; + } + + else if (firstPresent > 0 && secondPresent > 0) + // Both fields are present + { + return aFirst.GetStringL(EPIMEventSummary, 0).CompareC( + aSecond.GetStringL(EPIMEventSummary, 0)); + } + + // If start time AND summary are missing in both items, they are equal. + return 0; +} + +// End of File