/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of the add contact observer functionality.
*
*/
//User include
#include "addcontactobserver.h"
#include "contactcallback.h"
//System include
#include "contactservice.h"// for iContactService
#include <MVPbkContactStore.h>// for iContactStore
#include <MVPbkStoreContact.h>// used in many function to get the store contact
#include <MVPbkContactOperationBase.h>//for observer
#include <MVPbkContactLink.h>//for param in ContactsSaved()
#include <MVPbkContactGroup.h>
#include <MVPbkContactFieldTextData.h>
#include <MVPbkContactFieldData.h>
#include <MVPbkContactFieldBinaryData.h>
#include <MVPbkContactFieldDateTimeData.h>
#include <MVPbkContactFieldUriData.h>
/*
-------------------------------------------------------------------------------------
CAddContactObserver::NewL( CContactService* aContactService,
MVPbkContactStore* aContactStore,
CSingleContact* aStoreContact,
const TDesC8& aGroupId,
const TDesC& aGroupLabel,
TInt aTransId,
MContactCallback* aCallback)
Description : Static method to create instance of add contact observer.
Return values : CAddContactObserver*
-------------------------------------------------------------------------------------
*/
CAddContactObserver* CAddContactObserver::NewL(CContactService* aContactService,
MVPbkContactStore* aContactStore,
CSingleContact* aStoreContact,
const TDesC8& aGroupId,
const TDesC& aGroupLabel,
TInt aTransId,
MContactCallback* aCallback)
{
CAddContactObserver* self = new( ELeave )
CAddContactObserver(aContactService,
aContactStore,
aStoreContact,
aTransId,
aCallback);
CleanupStack::PushL(self);
self->ConstructL(aGroupId,aGroupLabel);
CleanupStack::Pop(self);
return self;
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::CAddContactObserver(CVPbkContactManager* aContactManager,
MVPbkContactStore* aContactStore,
CSingleContact* aStoreContact,
TInt aTransId,
MContactCallback* aCallback)
Description : This is the default constructor
Return values : N/A
-------------------------------------------------------------------------------------
*/
CAddContactObserver::CAddContactObserver( CContactService* aContactService,
MVPbkContactStore* aContactStore,
CSingleContact* aStoreContact,
TInt aTransId,
MContactCallback* aCallback )
{
iContactService = aContactService;
iContactStore = aContactStore;
iStoreContact = aStoreContact;
iGroupId = NULL;
iGroupLabel = NULL;
iTransId = aTransId;
iCallback = aCallback;
iLockFlag = EFalse;
iContact = NULL;
iGroup = NULL;
iOp = NULL;
iErrorID = 0;
}
void CAddContactObserver::ConstructL(const TDesC8& aGroupId,
const TDesC& aGroupLabel)
{
iGroupId = HBufC8 :: NewL(aGroupId.Length());
*iGroupId = aGroupId;
iGroupLabel = HBufC :: NewL(aGroupLabel.Length());
*iGroupLabel = aGroupLabel;
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::~CAddContactObserver()
Description : Destructor
Return values : N/A
-------------------------------------------------------------------------------------
*/
CAddContactObserver::~CAddContactObserver()
{
delete iGroupId;
delete iGroupLabel;
delete iContact;
delete iGroup;
if(iOp)
{
delete iOp;
}
if(iContactStore)
{
iContactStore->Close(*this);
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::Cancel()
Description : Cancel implementation relevant to AddObserver
Return values : KErrorNone on Success and KErrGeneral on Failure
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::Cancel()
{
iCallback->HandleReturnValue(EOpCancel, KErrNone, iTransId);
delete this;
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::CreateAndAddFieldToContactL()
Description : This method creates the contact field and adds to the data base.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::CreateAndAddFieldToContactL()
{
TPtrC8 fieldKey(KNullDesC8);
TPtrC label(KNullDesC);
TPtrC value(KNullDesC);
TBool labelFound = EFalse;
iErrorID = 0;
TBuf16<100> bufVal;
int len =0;
TBool xspidField = EFalse;
TBool secTime = EFalse;
TInt fieldCount = iStoreContact->FieldCount();
const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());
for(TInt index = 0; index < fieldCount; index++)
{
xspidField = EFalse;
CSingleContactField* field = iStoreContact->FieldAt(index);
field->GetFieldDataL(fieldKey, label, value);
TInt fieldTypeResId = CSearchFields::GetIdFromFieldKey(fieldKey);
iErrorID = fieldTypeResId;
MVPbkStoreContactField* cntField =
iContact->CreateFieldLC( * contactManager->FieldTypes().Find( fieldTypeResId ) );
iErrorID = 0;
TVPbkFieldStorageType storageType = cntField->FieldData().DataType();
if( EVPbkFieldStorageTypeBinary == storageType )
{
//(MVPbkContactFieldBinaryData::Cast(cntField->FieldData())).SetBinaryDataL( value8bit );
}
else if( EVPbkFieldStorageTypeDateTime == storageType )
{
TTime timeVal = field->GetDateTime();
(MVPbkContactFieldDateTimeData::Cast(cntField->FieldData())).SetDateTime( timeVal );
}
else if(EVPbkFieldStorageTypeUri == storageType )
{
xspidField = ETrue;
RPointerArray<HBufC> xspidArray;
//CleanupClosePushL(xspidArray);
field->GetXspidDataL(xspidArray);
TInt count = xspidArray.Count();
for(int i=0; i<count; i++)
{
if(secTime != EFalse)
{
fieldTypeResId = CSearchFields::GetIdFromFieldKey(fieldKey);
iErrorID = fieldTypeResId;
cntField = iContact->CreateFieldLC( * contactManager->FieldTypes().Find( fieldTypeResId ) );
iErrorID = 0;
storageType = cntField->FieldData().DataType();
}
secTime = ETrue;
HBufC* val = xspidArray[i];
bufVal.Copy(val->Des());
TDes16 desVal = bufVal;
TPtrC ptrVal; //desVal.Left(0);
TInt valLen = val->Length();
//(MVPbkContactFieldUriData::Cast(cntField->FieldData())).SetUriL( bufVal );
(static_cast<MVPbkContactFieldUriData&>(cntField->FieldData())).SetUriL( bufVal );
len = val->Find(_L(":"));
if(len != -1)
{
TInt trimLen = valLen - len;
ptrVal.Set(val->Left(valLen - (trimLen)));
len =0;
TRAP_IGNORE(cntField->SetFieldLabelL(ptrVal));
iContact->AddFieldL(cntField);
CleanupStack::Pop(); //cntField
}
else
{
CleanupStack::Pop(); //cntField
User::Leave(KErrArgument);
}
// delete val;
}
xspidArray.Reset();
//CleanupStack::Pop();
}
else
{
(MVPbkContactFieldTextData::Cast(cntField->FieldData())).SetTextL( value );
}
if(xspidField == EFalse)
{
TRAP_IGNORE(cntField->SetFieldLabelL(label));
iContact->AddFieldL(cntField);
CleanupStack::Pop(); //cntField
}
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::DoAddL()
Description : Called for 1) Adding a new contact/group to the contacts database.
2) Editing a contact/group from the contacts database.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::DoAddL()
{
//if iStoreContact is non-null pointer then it is a new contact or existing contact.
if( iStoreContact )
{
//get contact id from the contact.
TPtrC8 cntId = iStoreContact->GetContactId();
//If cntId is null then it is new contact, get the fields from the CSingleContact
//create new contact, add the fields to it and commit the contact.
if( cntId == KNullDesC8 )
{
iContact = iContactStore->CreateNewContactLC();
CleanupStack::Pop(); //contact
CreateAndAddFieldToContactL();
iContact->CommitL(*this);
}
else //Edit contact : retrieve contact and update the fields and commit.
{
const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());
MVPbkContactLinkArray* linkArray = contactManager->CreateLinksLC(cntId);
const MVPbkContactLink* link = &(linkArray->At(0));
CleanupStack::Pop(); //linkArray
MVPbkContactOperationBase* iOp =contactManager->RetrieveContactL(*link, *this);
}
}
//group id is not null and grp label is not null then exiting grp,
//retrieve the grp,and edit the label.
else if( *iGroupId != KNullDesC8 && *iGroupLabel != KNullDesC )
{
const CVPbkContactManager* contactManager = &(iContactService->GetContactManager());
MVPbkContactLinkArray* linkArray = contactManager->CreateLinksLC(*iGroupId);
const MVPbkContactLink* link = &(linkArray->At(0));
CleanupStack::Pop(); //linkArray
contactManager->RetrieveContactL(*link, *this);
}
//if grp id is null and grp label is non-null then, create new grp and set the label.
else if( *iGroupId == KNullDesC8 && *iGroupLabel != KNullDesC )
{
iGroup = iContactStore->CreateNewContactGroupLC();
iGroup->SetGroupLabelL(*iGroupLabel);
iGroup->CommitL( *this );
CleanupStack::Pop(); //group
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::DoCommitL()
Description : Commit contact to the contacts database.
Return values : TInt
-------------------------------------------------------------------------------------
*/
TInt CAddContactObserver::DoCommitL( TContactOpResult aResult )
{
TInt retVal = KErrGeneral;
//if lockflag is true, opcode is EContactLock, group id is not null
//and grp label is not null then exiting grp, get ptr to grp from
//contact and edit the label and commit the same.
if( iLockFlag &&
aResult.iOpCode == EContactLock &&
((*iGroupId != KNullDesC8) && (*iGroupLabel != KNullDesC)) )
{
MVPbkContactGroup* grpintf = iContact->Group();
if(grpintf != NULL)
{
grpintf->SetGroupLabelL(*iGroupLabel);
(iContact->Group())->CommitL(*this);
//set lock flag to false, as it is done.
iLockFlag = EFalse;
//set return value to ErrNone...completed successfully.
retVal = KErrNone;
}
}
//lock is success, so update the fields in the contact and commit.
else if( iLockFlag && aResult.iOpCode == EContactLock )
{
//remove all the fields from the original contact.
iContact->RemoveAllFields();
//add new fields to the contact;
CreateAndAddFieldToContactL( );
//added all the fields...commit the contact.
iContact->CommitL( *this );
//set lock flag to false, as it is done.
iLockFlag = EFalse;
//set return value to ErrNone...completed successfully.
retVal = KErrNone;
}
else if( aResult.iOpCode == EContactCommit )
{
retVal = KErrNone;
}
return retVal;
}
/*
-------------------------------------------------------------------------------------
void CAddContactObserver::DoEditContactOrGroupL(MVPbkStoreContact* aContact)
Description : This method is used to edit the group,it locks
the contact to be edited and performs the edit operation.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::DoEditContactOrGroupL(MVPbkStoreContact* aContact)
{
//Edit contact : lock the contact for edit operation.
iLockFlag = ETrue;
aContact->LockL(*this);
if(!iContact )
{
iContact = aContact;
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::ContactOperationCompleted( TContactOpResult aResult )
Description : Virtual Phonebook Observer method called back once
the contact operation is completed successfully.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::ContactOperationCompleted( TContactOpResult aResult )
{
//if lock operation is successfull then it enters here...
//call DoCommitL(), to commit the contact into the contact store.
TRAPD(error, error = DoCommitL(aResult));
if(error == KErrNone)
{
//notify the user with the status of the operation.
if((aResult.iOpCode != EContactLock) || (error != KErrNone))
{
//iContactService->RequestComplete(iTransId);
//iCallback->HandleReturnValue(EOpComplete, error, iTransId);
if(iGroupLabel->Compare(KNullDesC) != 0) //.Compare(KNullDesC)) != 0)
{
if(iGroup != NULL)
{
iContactService->RequestComplete(iTransId);
MVPbkContactLink* link = iGroup->CreateLinkLC();
HBufC8* grpId = link->PackLC();
CleanupStack::Pop(grpId);
iCallback->HandleReturnId(error, grpId, iTransId);
CleanupStack::PopAndDestroy();
//delete grpId;
delete this;
}
else
{
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpComplete, error, iTransId);
delete this;
}
}
else
{
if(iContact != NULL)
{
iContactService->RequestComplete(iTransId);
MVPbkContactLink* link = iContact->CreateLinkLC();
HBufC8* cntId = link->PackLC();
CleanupStack::Pop(cntId);
iCallback->HandleReturnId(error, cntId, iTransId);
CleanupStack::PopAndDestroy();
// delete cntId;
delete this;
}
else
{
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpComplete, error, iTransId);
delete this;
}
}
}
}
else
{
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpError, error, iTransId);
delete this;
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::ContactOperationFailed(TContactOp aOpCode,
TInt aErrorCode,
TBool aErrorNotified)
Description : Virtual Phonebook Observer method called back if
the contact operation is Failed.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::ContactOperationFailed(TContactOp /*aOpCode*/,
TInt aErrorCode,
TBool /*aErrorNotified*/)
{
//operation failed....handle the error
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpError, aErrorCode, iTransId);
delete this;
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::ContactOperationFailed(TContactOp aOpCode,
TInt aErrorCode,
TBool aErrorNotified)
Description : Virtual Phonebook Observer method called back when OpenL(),
the database open operation is successfull.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::StoreReady(MVPbkContactStore& aContactStore)
{
iContactStore = &aContactStore;
TRAPD(error, DoAddL());
if( error != KErrNone )
{
iContactService->RequestComplete(iTransId);
if(error == KErrNotSupported && iErrorID != 0)
{
iCallback->HandleReturnValue(EInvalidKey, iErrorID, iTransId);
}
else
{
iCallback->HandleReturnValue(EOpComplete, error, iTransId);
}
delete this;
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::StoreUnavailable(MVPbkContactStore& aContactStore,
TInt aReason)
Description : Virtual Phonebook Observer method called back when OpenL(),
the database open operation is failed due to unavailable store.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::StoreUnavailable(MVPbkContactStore& /*aContactStore*/,
TInt aReason)
{
//store open failed.....handle the error
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpError, aReason, iTransId);
delete this;
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::HandleStoreEventL(MVPbkContactStore& aContactStore,
TVPbkContactStoreEvent aStoreEvent)
Description : Virtual Phonebook Observer method Not used here.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::HandleStoreEventL(MVPbkContactStore& /*aContactStore*/,
TVPbkContactStoreEvent /*aStoreEvent*/)
{
//do nothing here
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::VPbkSingleContactOperationComplete
(MVPbkContactOperationBase& aOperation,
MVPbkStoreContact* aContact)
Description : Virtual Phonebook Observer method called back when
Single Contact Operation completes successfully..
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::VPbkSingleContactOperationComplete
(MVPbkContactOperationBase& aOperation,
MVPbkStoreContact* aContact)
{
delete &aOperation;
TRAPD(error, DoEditContactOrGroupL(aContact));
if(KErrNone != error)
{
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpComplete, error, iTransId);
delete this;
}
}
/*
-------------------------------------------------------------------------------------
CAddContactObserver::VPbkSingleContactOperationFailed
(MVPbkContactOperationBase& aOperation,
TInt aError)
Description : Virtual Phonebook Observer method called back when
Single Contact Operation fails.
Return values : N/A
-------------------------------------------------------------------------------------
*/
void CAddContactObserver::VPbkSingleContactOperationFailed
(MVPbkContactOperationBase& aOperation,
TInt aError)
{
delete &aOperation;
iContactService->RequestComplete(iTransId);
iCallback->HandleReturnValue(EOpError, aError, iTransId);
delete this;
}