diff -r 000000000000 -r e686773b3f54 phonebookengines/VirtualPhonebook/VPbkCntModel/src/CDefaultAttributeManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookengines/VirtualPhonebook/VPbkCntModel/src/CDefaultAttributeManager.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,606 @@ +/* +* Copyright (c) 2002-2007 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: The virtual phonebook default attribute manager +* +*/ + + + +#include "CDefaultAttributeManager.h" +#include "CDefaultAttributeOperation.h" + +// From Virtual Phonebook +#include +#include +#include +#include +#include +#include +#include +#include + +// From VPbkCntModel +#include "CContactStore.h" +#include "CContact.h" +#include "VPbkCntModelUid.h" + +// From Contacts Model +#include + + +namespace VPbkCntModel { + +namespace { + + struct TFieldTypePair + { + TInt iProperty; + TInt iUid; + }; + + static const TFieldTypePair fieldTypeMap[] = + { + /// default phone number field type + {EVPbkDefaultTypePhoneNumber, KIntVPbkDefaultFieldPref}, + /// default video number field type + {EVPbkDefaultTypeVideoNumber, KIntVPbkDefaultFieldVideo}, + /// default sms field type + {EVPbkDefaultTypeSms, KIntVPbkDefaultFieldSms}, + /// default mms field type + {EVPbkDefaultTypeMms, KIntVPbkDefaultFieldMms}, + /// default email field type + {EVPbkDefaultTypeEmail, KIntVPbkDefaultFieldPref}, + /// default email over sms field type + {EVPbkDefaultTypeEmailOverSms, KIntVPbkDefaultFieldEmailOverSms}, + /// default poc field type + {EVPbkDefaultTypePOC, KIntVPbkDefaultFieldPoc}, + /// default voip field type + {EVPbkDefaultTypeVoIP, KIntVPbkDefaultFieldVoip}, + /// default chat field type + {EVPbkDefaultTypeChat, KIntVPbkDefaultFieldChat}, + /// default url field type + {EVPbkDefaultTypeOpenLink, KIntVPbkDefaultFieldOpenLink}, + + + + // Always the last one + {EVPbkLastDefaultType, 0} + }; + + TFieldType FindFieldTypeForProperty(TVPbkDefaultType aProperty) + { + for (TInt i = 0; fieldTypeMap[i].iProperty != EVPbkLastDefaultType; + ++i) + { + if (aProperty == fieldTypeMap[i].iProperty) + { + return TFieldType::Uid(fieldTypeMap[i].iUid); + } + + } + return KNullUid; + } + + TBool IsFieldType( const TContactField& aField, TUid aUid ) + { + for (TInt i = 0; i < aField.NativeField()-> + ContentType().FieldTypeCount(); ++i ) + { + if ( aField.NativeField()->ContentType().FieldType( i ) == + aUid ) + { + return ETrue; + } + } + return EFalse; + } + +} // unnamed namespace + +CDefaultAttributeManager::CDefaultAttributeManager( + CVPbkContactManager& aContactManager) : + iContactManager(aContactManager) + { + } + +inline void CDefaultAttributeManager::ConstructL() + { + } + +CDefaultAttributeManager* CDefaultAttributeManager::NewL(TAny* aParam) + { + TParam& param = *static_cast(aParam); + CDefaultAttributeManager* self = new(ELeave) CDefaultAttributeManager( + param.iContactManager); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CDefaultAttributeManager::~CDefaultAttributeManager() + { + } + +MVPbkContactOperationBase* CDefaultAttributeManager::ListContactsL( + TUid /*aAttributeType*/, + MVPbkContactFindObserver& /*aObserver*/) + { + __ASSERT_DEBUG(EFalse, User::Leave(KErrNotSupported)); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::ListContactsL( + const MVPbkContactAttribute& /*aAttribute*/, + MVPbkContactFindObserver& /*aObserver*/) + { + __ASSERT_DEBUG(EFalse, User::Leave(KErrNotSupported)); + return NULL; + } + +MVPbkContactOperation* CDefaultAttributeManager::CreateListContactsOperationL( + TUid aAttributeType, + MVPbkContactFindObserver& aObserver) + { + MVPbkContactOperation* result = NULL; + + if (aAttributeType == CVPbkDefaultAttribute::Uid()) + { + CVPbkDefaultAttribute* attribute = CVPbkDefaultAttribute::NewL( + CVPbkDefaultAttribute::KDefaultTypeNotDefined); + CleanupStack::PushL(attribute); + result = CreateListContactsOperationL(*attribute, aObserver); + CleanupStack::PopAndDestroy(attribute); + } + + return result; + } + +MVPbkContactOperation* CDefaultAttributeManager::CreateListContactsOperationL( + const MVPbkContactAttribute& aAttribute, + MVPbkContactFindObserver& aObserver) + { + MVPbkContactOperation* result = NULL; + + if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid()) + { + + const CVPbkDefaultAttribute& attribute = + static_cast(aAttribute); + + MVPbkContactStore* store = iContactManager.ContactStoresL().Find( + KVPbkDefaultCntDbURI()); + if (store) + { + CContactStore& cntStore = *static_cast(store); + result = CDefaultAttributeOperation::NewListLC( + cntStore, + attribute, + aObserver); + result->StartL(); + CleanupStack::Pop(); + } + else + { + User::Leave(KErrNotSupported); + } + } + + return result; + } + +TBool CDefaultAttributeManager::HasContactAttributeL( + TUid aAttributeType, + const MVPbkStoreContact& aContact) const + { + TBool result = EFalse; + + if (aAttributeType == CVPbkDefaultAttribute::Uid()) + { + const CContact* contact = dynamic_cast(&aContact); + if (contact) + { + CContactItemFieldSet& fields = contact->NativeContact()->CardFields(); + const TInt count = fields.Count(); + for (TInt i = 0; i < count && !result; ++i) + { + // Loop through all defaults and check if field contains + // that type. If any field of contact contains any default + // we can break. + for (TInt n = 0; + fieldTypeMap[n].iProperty != EVPbkLastDefaultType; + ++n) + { + TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid); + if (fields[i].ContentType().ContainsFieldType(fieldType)) + { + result = ETrue; + break; + } + } + } + } + } + + return result; + } + +TBool CDefaultAttributeManager::HasContactAttributeL( + const MVPbkContactAttribute& aAttribute, + const MVPbkStoreContact& aContact) const + { + TBool result = EFalse; + + if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid()) + { + // Make sure that aContact is from CntModel store + const CContact* contact = dynamic_cast(&aContact); + if (contact) + { + const CVPbkDefaultAttribute& attribute = + static_cast(aAttribute); + if (attribute.DefaultType() == CVPbkDefaultAttribute::KDefaultTypeNotDefined) + { + // If default type is not defined, we try to match any default field + result = HasContactAttributeL(aAttribute.AttributeType(), aContact); + } + else + { + // There is already dynamic_cast + TFieldType fieldType = FindFieldTypeForProperty(attribute.DefaultType()); + CContactItemFieldSet& fields = contact->NativeContact()->CardFields(); + const TInt count = fields.Count(); + for (TInt i = 0; i < count && !result; ++i) + { + if (fields[i].ContentType().ContainsFieldType(fieldType)) + { + result = ETrue; + break; + } + } + } + } + } + + return result; + } + +TBool CDefaultAttributeManager::HasFieldAttributeL( + TUid aAttributeType, + const MVPbkStoreContactField& aField) const + { + TBool result = EFalse; + + // Make sure that aField is from CntModel store + if (aAttributeType == CVPbkDefaultAttribute::Uid()) + { + const TContactField* field = dynamic_cast(&aField); + if ( field ) + { + // Loop through all defaults and check if field contains + // that type. + for (TInt n = 0; + fieldTypeMap[n].iProperty != EVPbkLastDefaultType; + ++n) + { + TFieldType fieldType = TFieldType::Uid(fieldTypeMap[n].iUid); + if (field->NativeField()->ContentType().ContainsFieldType(fieldType)) + { + result = ETrue; + break; + } + } + } + } + return result; + } + +TBool CDefaultAttributeManager::HasFieldAttributeL( + const MVPbkContactAttribute& aAttribute, + const MVPbkStoreContactField& aField) const + { + TBool result = EFalse; + + if (aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid()) + { + const TContactField* field = dynamic_cast(&aField); + if ( field ) + { + const CVPbkDefaultAttribute& attribute = + static_cast( aAttribute ); + if ( attribute.DefaultType() == + CVPbkDefaultAttribute::KDefaultTypeNotDefined ) + { + result = HasFieldAttributeL( aAttribute.AttributeType(), + aField ); + } + else + { + TFieldType fieldType = + FindFieldTypeForProperty( attribute.DefaultType() ); + // If checking for email default we have to check that field is email + // field, because default phone and email has same id + // KIntVPbkDefaultFieldPref Field has specified default + if ( field->NativeField()-> + ContentType().ContainsFieldType(fieldType) ) + { + // Only Email field can be set as email default + if ( attribute.DefaultType() == EVPbkDefaultTypeEmail ) + { + if ( IsFieldType( *field, KUidContactFieldEMail ) ) + { + result = ETrue; + } + } + else if ( attribute.DefaultType() == EVPbkDefaultTypePhoneNumber ) + { + // Phone number default and field is not email field + if ( !IsFieldType( *field, KUidContactFieldEMail ) ) + { + result = ETrue; + } + } + else + { + result = ETrue; + } + } + } + } + } + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::SetContactAttributeL( + const MVPbkContactLink& /*aContactLink*/, + const MVPbkContactAttribute& aAttribute, + MVPbkSetAttributeObserver& /*aObserver*/) + { + MVPbkContactOperationBase* result = NULL; + + if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() ) + { + User::Leave( KErrNotSupported ); + } + + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::SetFieldAttributeL( + MVPbkStoreContactField& aField, + const MVPbkContactAttribute& aAttribute, + MVPbkSetAttributeObserver& aObserver ) + { + MVPbkContactOperation* result = NULL; + + if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() ) + { + TContactField* field = dynamic_cast( &aField ); + if ( field ) + { + const CVPbkDefaultAttribute& attribute = + static_cast( aAttribute ); + if ( attribute.DefaultType() == + CVPbkDefaultAttribute::KDefaultTypeNotDefined ) + { + User::Leave( KErrArgument ); + } + else + { + // Safe to cast because the field is contact model field + CContactStore& store = static_cast( + aField.ParentObject().ContactStore() ); + result = CDefaultAttributeOperation::NewSetLC( + store, aField, attribute, aObserver ); + result->StartL(); + CleanupStack::Pop(); // result + } + } + } + + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::RemoveContactAttributeL( + const MVPbkContactLink& /*aContactLink*/, + const MVPbkContactAttribute& aAttribute, + MVPbkSetAttributeObserver& /*aObserver*/) + { + MVPbkContactOperationBase* result = NULL; + + if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() ) + { + User::Leave( KErrNotSupported ); + } + + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::RemoveContactAttributeL( + const MVPbkContactLink& /*aContactLink*/, + TUid aAttributeType, + MVPbkSetAttributeObserver& /*aObserver*/) + { + MVPbkContactOperationBase* result = NULL; + + if ( aAttributeType == CVPbkDefaultAttribute::Uid() ) + { + User::Leave( KErrNotSupported ); + } + + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::RemoveFieldAttributeL( + MVPbkStoreContactField& aField, + const MVPbkContactAttribute& aAttribute, + MVPbkSetAttributeObserver& aObserver ) + { + MVPbkContactOperation* result = NULL; + + if ( dynamic_cast(&aField) ) + { + if ( aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() ) + { + const CVPbkDefaultAttribute& attribute = + static_cast( aAttribute ); + + MVPbkContactStore* store = iContactManager.ContactStoresL().Find( + KVPbkDefaultCntDbURI() ); + if ( store ) + { + VPbkCntModel::CContactStore& cntStore = + *static_cast( store ); + result = CDefaultAttributeOperation::NewRemoveLC( + cntStore, aField, attribute, aObserver ); + result->StartL(); + CleanupStack::Pop(); // result + } + else + { + User::Leave( KErrNotSupported ); + } + } + } + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::RemoveFieldAttributeL( + MVPbkStoreContactField& aField, + TUid aAttributeType, + MVPbkSetAttributeObserver& aObserver ) + { + MVPbkContactOperationBase* result = NULL; + + if ( dynamic_cast(&aField) ) + { + if ( aAttributeType == CVPbkDefaultAttribute::Uid() ) + { + CVPbkDefaultAttribute* attribute = CVPbkDefaultAttribute::NewL( + CVPbkDefaultAttribute::KDefaultTypeNotDefined ); + CleanupStack::PushL( attribute ); + result = RemoveFieldAttributeL( aField, *attribute, aObserver ); + CleanupStack::PopAndDestroy( attribute ); + } + } + return result; + } + +MVPbkStoreContactFieldCollection* CDefaultAttributeManager::FindFieldsWithAttributeLC( + TUid aAttributeType, + MVPbkStoreContact& aContact ) const + { + CVPbkContactFieldCollection* result = NULL; + + if (dynamic_cast( &aContact ) && + aAttributeType == CVPbkDefaultAttribute::Uid() ) + { + result = CVPbkContactFieldCollection::NewLC(aContact); + const TInt count = aContact.Fields().FieldCount(); + for ( TInt i = 0; i < count; ++i ) + { + MVPbkStoreContactField& field = aContact.Fields().FieldAt( i ); + if ( HasFieldAttributeL(aAttributeType, field) ) + { + MVPbkStoreContactField* clone = field.CloneLC(); + result->AppendL( clone ); + CleanupStack::Pop(); // clone + } + } + } + return result; + } + +MVPbkStoreContactFieldCollection* CDefaultAttributeManager::FindFieldsWithAttributeLC( + const MVPbkContactAttribute& aAttribute, + MVPbkStoreContact& aContact) const + { + CVPbkContactFieldCollection* result = NULL; + + if ( dynamic_cast( &aContact ) && + aAttribute.AttributeType() == CVPbkDefaultAttribute::Uid() ) + { + result = CVPbkContactFieldCollection::NewLC( aContact ); + const TInt count = aContact.Fields().FieldCount(); + for ( TInt i = 0; i < count; ++i ) + { + MVPbkStoreContactField& field = aContact.Fields().FieldAt(i); + if ( HasFieldAttributeL( aAttribute, field ) ) + { + MVPbkStoreContactField* clone = field.CloneLC(); + result->AppendL( clone ); + CleanupStack::Pop(); // clone + } + } + } + return result; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::HasContactAttributeL( + TUid /*aAttributeType*/, + const MVPbkStoreContact& /*aContact*/, + MVPbkSingleAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::HasContactAttributeL( + const MVPbkContactAttribute& /*aAttribute*/, + const MVPbkStoreContact& /*aContact*/, + MVPbkSingleAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::HasFieldAttributeL( + TUid /*aAttributeType*/, + const MVPbkStoreContactField& /*aField*/, + MVPbkSingleAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::HasFieldAttributeL( + const MVPbkContactAttribute& /*aAttribute*/, + const MVPbkStoreContactField& /*aField*/, + MVPbkSingleAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::FindFieldsWithAttributeL( + TUid /*aAttributeType*/, + MVPbkStoreContact& /*aContact*/, + MVPbkMultiAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +MVPbkContactOperationBase* CDefaultAttributeManager::FindFieldsWithAttributeL( + const MVPbkContactAttribute& /*aAttribute*/, + MVPbkStoreContact& /*aContact*/, + MVPbkMultiAttributePresenceObserver& /*aObserver*/) const + { + User::Leave( KErrNotSupported ); + return NULL; + } + +} // namespace VPbkCntModel + +// End of File