diff -r 000000000000 -r e686773b3f54 pimprotocols/phonebooksync/plugin/phbksyncplugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimprotocols/phonebooksync/plugin/phbksyncplugin.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,584 @@ +// Copyright (c) 2002-2009 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: +// Contains the Phonebook Synchroniser Plug-in implementation. +// +// + +#include +#include +#include +#include +#include + +#include "phbksyncplugin.h" +#include "phbksynclog.h" +#include "SyncContactICCEntry.h" +#include "PhonebookManager.h" +#include "SyncEngineServer.h" + + + +/** + * Validate the contact data specified by aId can be read, edited or searched. + * + * @param aOp Validate operation requested (read/edit/search) + * @param aId Contact item ID + */ +TInt CPhoneBookSyncPlugin::ValidateContact(TValidateOperation aOp, TContactItemId aId) + { + LOGPLUGIN3(_L8("ValidateContact(%d, 0x%08x)"), aOp, aId); + +#ifdef SYMBIAN_CNTMODEL_V2 + return iSession.ValidateContact(aOp, aId); +#else + if (!iInServerThread) + { + return iSession.ValidateContact(aOp, aId); + } + else + { + return KErrNone; + } +#endif // SYMBIAN_CNTMODEL_V2 + } // CPhoneBookSyncPlugin::ValidateContact + + +/** + * Write the contact data specified by aContactItem to the ICC. The slot + * number used to write the data is specified by the KUidContactFieldICCSlot + * field. Similarly the phonebook Uid is specified by the KUidContactFieldICCPhonebook + * field. + * + * @param aContactItem Contact item to write. + * + * @return KErrNone if write to ICC was successful, otherwise return error + */ +TInt CPhoneBookSyncPlugin::ValidateWriteContact(CContactICCEntry& aContactItem) + { + LOGPLUGIN1(_L8("ValidateWriteContact()")); + +#ifndef SYMBIAN_CNTMODEL_V2 + if (!iInServerThread) + { +#endif // SYMBIAN_CNTMODEL_V2 + + TRequestStatus status(0); + TInt slotNum = ICCSlotNumber(aContactItem); + + TUid phonebookUid(TUid::Null()); // First check whether phonebook field is supplied + TRAPD(error, phonebookUid = ICCPhonebookL(aContactItem)); + if (error != KErrNone) + { + return error; + } + + TBuf buf; + + if (phonebookUid == KUidIccPhonebookNotSpecified) // phonebook field not set within aContactItem + { + iSession.WriteContact(status, aContactItem, slotNum); + } + else + { + iSession.WriteContact(status, aContactItem, slotNum, phonebookUid); + } + User::WaitForRequest(status); + TInt ret(status.Int()); + + if (ret == KErrNone) + { + // Server has added slot number, so add it to aContactItem + buf.Zero(); + buf.AppendNum(slotNum); + TRAP(ret, AddFieldValueL(aContactItem, KUidContactFieldICCSlot, buf)); + if(phonebookUid != KUidIccPhonebookNotSpecified) + // Server has added phonebook Uid, so add it to aContactItem + { + buf.Zero(); + buf.AppendNum(TUint(phonebookUid.iUid)); // Append integer part of UID as actual field value + TRAP(ret, AddFieldValueL(aContactItem, KUidContactFieldICCPhonebook, buf)); + } + } + + return ret; + +#ifndef SYMBIAN_CNTMODEL_V2 + } + else + { + return KErrNone; + } +#endif // SYMBIAN_CNTMODEL_V2 + } // CPhoneBookSyncPlugin::ValidateWriteContact + + +/** + * Delete the contact data from the ICC at the slot number specified + * in the CContactICCEntry item ID specified. + * + * @param aId Contact Item ID + * + * @return KErrNone if ICC deletion was successful, otherwise return error + */ +TInt CPhoneBookSyncPlugin::DeleteContact(TContactItemId aId) + { + LOGPLUGIN2(_L8("DeleteContact(0x%08x)"), aId); + +#ifndef SYMBIAN_CNTMODEL_V2 + if (!iInServerThread) + { +#endif // SYMBIAN_CNTMODEL_V2 + + TRequestStatus status; + iSession.DeleteContact(status, aId); + User::WaitForRequest(status); + return status.Int(); + +#ifndef SYMBIAN_CNTMODEL_V2 + } + else + { + return KErrNone; + } +#endif // SYMBIAN_CNTMODEL_V2 + } // CPhoneBookSyncPlugin::DeleteContact + + +/** + * Release any resources allocated by the plug-in and delete itself. + * + * This method is called by the destructor of Contact model's + * CContactDatabase class - ensuring it will be called when the plug-in + * is unloaded. + */ +void CPhoneBookSyncPlugin::Release() + { + LOGPLUGIN1(_L8("Release()")); + + iSession.Close(); + delete this; + } // CPhoneBookSyncPlugin::Release + + +/** + * Update the lookup tables in the server. + * This method is called by the Contacts model when a new CContactICCEntry + * has been added to the database. + * + * This is only important when it is done by a client other than the + * phonebook synchronisation server because the sync server can do the + * update when it knows what the UID of the newly added contact was. + * + * The plug-in should extract the appropriate details from the item + * (eg. item UID, slot number and ICC phonebook type) and call the sync server to + * update the lookup tables. + * + * @param aContactItem Contact Entry to update in the look up table. + */ +void CPhoneBookSyncPlugin::UpdatePostWriteL(const CContactICCEntry& aContactItem) + { + LOGPLUGIN1(_L8("UpdatePostWriteL()")); + +#ifndef SYMBIAN_CNTMODEL_V2 + if (iInServerThread) + { + return; + } +#endif // SYMBIAN_CNTMODEL_V2 + + TContactItemId id(aContactItem.Id()); + TInt slotNum(ICCSlotNumber(aContactItem)); + // Extract phonebook type from CContactICCEntry + TUid phonebook(ICCPhonebookL(const_cast(aContactItem))); + + if(phonebook == KUidIccPhonebookNotSpecified) // Phonebook not specified so assume + { + iSession.UpdateLookuptable(id, slotNum); // Global/GSM ADN phonebook is used + } + else + { + iSession.UpdateLookuptable(id, slotNum, phonebook); // phonebook supplied + } + } // CPhoneBookSyncPlugin::UpdatePostWriteL + + +/** + * Return the template that should be used with CContactICCEntry items residing on the + * phonebook specified by the aPhonebookUid parameter. + * + * @param aPhonebookUid UID of ICC phonebook for which the template is needed + * + * @return Template item ID + */ +TContactItemId CPhoneBookSyncPlugin::ICCTemplateIdL(TUid aPhonebookUid) + { + LOGPLUGIN2(_L8("ICCTemplateIdL(0x%08x)"), aPhonebookUid); + + TContactItemId templateId(KNullContactId); + +#ifdef SYMBIAN_CNTMODEL_V2 + User::LeaveIfError(iSession.GetPhoneBookId(templateId, RPhoneBookSession::ESyncTemplateId, aPhonebookUid)); +#else + if (!iInServerThread) + { + User::LeaveIfError(iSession.GetPhoneBookId(templateId, RPhoneBookSession::ESyncTemplateId, aPhonebookUid)); + } +#endif // SYMBIAN_CNTMODEL_V2 + + return templateId; + } // CPhoneBookSyncPlugin::ICCTemplateIdL + + +/** + * Return the group to be used for the phonebook specified by the aPhonebookUid parameter. + * + * @param aPhonebookUid UID of ICC phonebook for which the group UID is required + * + * @return Group item ID + */ +TContactItemId CPhoneBookSyncPlugin::GroupIdL(TUid aPhonebookUid) + { + LOGPLUGIN2(_L8("GroupIdL(0x%08x)"), aPhonebookUid); + + TContactItemId groupId(KNullContactId); + +#ifdef SYMBIAN_CNTMODEL_V2 + User::LeaveIfError(iSession.GetPhoneBookId(groupId, RPhoneBookSession::ESyncGroupId, aPhonebookUid)); +#else + if (!iInServerThread) + { + User::LeaveIfError(iSession.GetPhoneBookId(groupId, RPhoneBookSession::ESyncGroupId, aPhonebookUid)); + } +#endif // SYMBIAN_CNTMODEL_V2 + + return groupId; + } // CPhoneBookSyncPlugin::GroupIdL + + +/** + * Request notification of a phbksync cache state change. + * + * @param aStatus Request to be completed. + */ +void CPhoneBookSyncPlugin::NotifySyncStateChange(TRequestStatus& aStatus, TUid aPhonebookUid) + { + LOGPLUGIN2(_L8("NotifySyncStateChange(0x%08x)"), aPhonebookUid); + +#ifndef SYMBIAN_CNTMODEL_V2 + __ASSERT_ALWAYS(!iInServerThread, User::Invariant()); +#endif // SYMBIAN_CNTMODEL_V2 + + iSession.NotifyPhBkCacheStateChange(aStatus, aPhonebookUid); + } // CPhoneBookSyncPlugin::NotifySyncStateChange + + +/** + * Cancel previous request for notification of phbksync cache state change. + */ +void CPhoneBookSyncPlugin::CancelNotifyRequest(TUid aPhonebookUid) + { + LOGPLUGIN2(_L8("CancelNotifyRequest(0x%08x)"), aPhonebookUid); + +#ifndef SYMBIAN_CNTMODEL_V2 + __ASSERT_ALWAYS(!iInServerThread, User::Invariant()); +#endif // SYMBIAN_CNTMODEL_V2 + + iSession.CancelRequest(ESyncNotifyCacheStateChangeCancelClient, aPhonebookUid); + } // CPhoneBookSyncPlugin::CancelNotifyRequest + + +/** + * Return the current synchronisation state of the synchroniser. + * If the state is EErrorDuringSync, this method leaves with the last sync + * error recorded. + * + * @return ETrue if cache valid. EFalse, otherwise + */ +TBool CPhoneBookSyncPlugin::IsSynchronisedL(TUid aPhonebookUid) + { + LOGPLUGIN2(_L8("IsSynchronisedL(0x%08x)"), aPhonebookUid); + +#ifndef SYMBIAN_CNTMODEL_V2 + __ASSERT_ALWAYS(!iInServerThread, User::Invariant()); +#endif // SYMBIAN_CNTMODEL_V2 + + RPhoneBookSession::TSyncState state; + + User::LeaveIfError(iSession.GetPhoneBookCacheState(state, aPhonebookUid)); + + if (state==RPhoneBookSession::EErrorDuringSync) + { + TInt syncError(KErrNone); + User::LeaveIfError(iSession.GetLastSyncError(syncError, aPhonebookUid)); + User::Leave(syncError); + } + + return (state==RPhoneBookSession::ECacheValid); + } // CPhoneBookSyncPlugin::IsSynchronisedL + +/** + * Returns the list of Phonebooks that may be present on the ICC. + * + * @param aPhonebookList List of the phonebooks. If successful this updated with current list of phonebooks, otherwise it is reset. + * @return KErrNone or a system wide error such as KErrNoMemory. + */ +TInt CPhoneBookSyncPlugin::PhonebookList(RArray& aPhonebookList) + { + LOGPLUGIN1(_L8("PhonebookList()")); + + // + // Empty the list to start with... + // + aPhonebookList.Reset(); + +#ifndef SYMBIAN_CNTMODEL_V2 + if (iInServerThread) + { + return KErrNone; + } +#endif // SYMBIAN_CNTMODEL_V2 + + // + // Return the list of phonebooks... + // + RPhoneBookSession::TSyncState state; + TInt result; + + result = iSession.GetPhoneBookCacheState(state, KUidIccGlobalAdnPhonebook); + if (result != KErrNotSupported && result != KErrNotFound) + { + result = aPhonebookList.Append(KUidIccGlobalAdnPhonebook); + if (result != KErrNone) + { + aPhonebookList.Reset(); + return result; + } + } + + result = iSession.GetPhoneBookCacheState(state, KUidIccGlobalSdnPhonebook); + if (result != KErrNotSupported && result != KErrNotFound) + { + result = aPhonebookList.Append(KUidIccGlobalSdnPhonebook); + if (result != KErrNone) + { + aPhonebookList.Reset(); + return result; + } + } + + result = iSession.GetPhoneBookCacheState(state, KUidIccGlobalLndPhonebook); + if (result != KErrNotSupported && result != KErrNotFound) + { + result = aPhonebookList.Append(KUidIccGlobalLndPhonebook); + if (result != KErrNone) + { + aPhonebookList.Reset(); + return result; + } + } + + result = iSession.GetPhoneBookCacheState(state, KUidUsimAppAdnPhonebook); + if (result != KErrNotSupported && result != KErrNotFound) + { + result = aPhonebookList.Append(KUidUsimAppAdnPhonebook); + if (result != KErrNone) + { + aPhonebookList.Reset(); + return result; + } + } + + result = iSession.GetPhoneBookCacheState(state, KUidIccGlobalFdnPhonebook); + if (result != KErrNotSupported && result != KErrNotFound) + { + result = aPhonebookList.Append(KUidIccGlobalFdnPhonebook); + if (result != KErrNone) + { + aPhonebookList.Reset(); + return result; + } + } + + return KErrNone; + } + + +/** + * Extract the ICC slot number from the ICC slot field. + * + * @param aContactItem CContactICCEntry item + * + * @return ICC Slot number + */ +TInt CPhoneBookSyncPlugin::ICCSlotNumber(const CContactICCEntry& aContactItem) const + { + LOGPLUGIN1(_L8("ICCSlotNumber()")); + + CContactItemFieldSet& fieldset = aContactItem.CardFields(); + TInt position = fieldset.Find(KUidContactFieldICCSlot); + TInt slotNum(KErrNotFound); + if (position != KErrNotFound) + { + const CContactItemField& field = fieldset[position]; + TPtrC iccSlotField = field.TextStorage()->Text(); + TLex input(iccSlotField); + /*TInt ignore = */ input.Val(slotNum); + } + + return slotNum; + } // CPhoneBookSyncPlugin::ICCSlotNumber + + +/** + * Extract the ICC phonebook Uid from the ICC phonebook field. It also creates the phonebook + * field if it is not supplied within aContactItem. + * + * @param aContactItem CContactICCEntry item + * + * @return TUid that represents the ICC Phonebook type + */ +TUid CPhoneBookSyncPlugin::ICCPhonebookL(CContactICCEntry& aContactItem) const + { + LOGPLUGIN1(_L8("ICCPhonebookL()")); + + TUid phonebookUid; + CContactItemFieldSet& fieldset = aContactItem.CardFields(); + TInt position = fieldset.Find(KUidContactFieldICCPhonebook); + + if (position != KErrNotFound) + { + const CContactItemField& field = fieldset[position]; + TPtrC phonebookField = field.TextStorage()->Text(); + TLex input(phonebookField); + input.Val(phonebookUid.iUid); + } + else // phonebook field not supplied within aContactItem, so create one + { + // Create phonebook type field within aContactItem + TBuf buf; + phonebookUid = KUidIccPhonebookNotSpecified; // default phonebook Uid value + buf.AppendNum(TUint(phonebookUid.iUid)); + TPtrC phonebookPtrC(buf.Ptr()); + CContactItemField* field=CContactItemField::NewLC(KStorageTypeText, KUidContactFieldICCPhonebook); + field->SetMapping(KUidContactFieldVCardMapNotRequired); + field->AddFieldTypeL(KUidContactFieldICCPhonebook); // Appends a field type to the field's content type + field->TextStorage()->SetTextL(phonebookPtrC); + aContactItem.AddFieldL(*field); // Add this phonebook field to ICC contact item + CleanupStack::Pop(field); // No need to destroy it since contact item takes ownership of field + } + + return phonebookUid; + } // CPhoneBookSyncPlugin::ICCPhonebookL + + +/** + * Add the field value aField supplied by the phonebook synchroniser to the + * item's field specified by the aFieldType parameter. + * + * @param aContactItem CContactICCEntry item + * @param aFieldType Field type + * @param aField Field data + */ +void CPhoneBookSyncPlugin::AddFieldValueL(CContactICCEntry& aContactItem, TFieldType aFieldType, + TDesC& aField) + { + LOGPLUGIN1(_L8("AddFieldValueL()")); + + CContactItemFieldSet& fieldset = aContactItem.CardFields(); + TInt position = fieldset.Find(aFieldType); + CContactItemField& field = fieldset[position]; + CContactTextField* textField = field.TextStorage(); + + if (!textField->IsFull()) + { + textField->SetTextL(aField); + } + } // CPhoneBookSyncPlugin::AddFieldValueL + + +/** + * Create a connection with the phonebook synchroniser server. + */ +void CPhoneBookSyncPlugin::ConstructL() + { + LOGPLUGIN1(_L8("ConstructL()")); + +#ifdef SYMBIAN_CNTMODEL_V2 + User::LeaveIfError(iSession.Connect()); +#else + TName threadName = RThread().Name(); + iInServerThread = (threadName.CompareF(PHBKSYNC_ENGINE_NAME)==0); + + if (!iInServerThread) + { + User::LeaveIfError(iSession.Connect()); + } +#endif // SYMBIAN_CNTMODEL_V2 + } // CPhoneBookSyncPlugin::ConstructL + + +/** + * Non-leaving factory construction method. + * + * @return Pointer to plug-in or NULL if plug-in construction unsuccessful + */ +CPhoneBookSyncPlugin* CPhoneBookSyncPlugin::New() + { + CPhoneBookSyncPlugin* self = NULL; + + TRAPD(err,self = NewL()); + + if (err != KErrNone) + { + return NULL; + } + else + { + return self; + } + } // CPhoneBookSyncPlugin::New + + +/** + * Standard factory construction method + */ +CPhoneBookSyncPlugin* CPhoneBookSyncPlugin::NewL() + { + CPhoneBookSyncPlugin* self = new (ELeave) CPhoneBookSyncPlugin(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return self; + } // CPhoneBookSyncPlugin::NewL + + +/** + * Implementation collection function. + */ +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(0x1020428D, CPhoneBookSyncPlugin::NewL) + }; + + +/** + * Return the implementation table size. + */ +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + + return ImplementationTable; + } // ImplementationGroupProxy