/*

* 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 "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:    Responsible for the importing of vCards

*

*/

// System includes

#include <s32file.h>                    // RFileReadStream

#include <f32file.h>                    // RFs 

#include <MVPbkContactStore.h>          // MVPbkContactStore

#include <CVPbkVCardEng.h>              // CVPbkVCardEng

#include <MVPbkContactOperationBase.h>  // MVPbkContactOperationBase

#include <MVPbkContactLinkArray.h>      // MVPbkContactLinkArray

#include <CVPbkContactLinkArray.h>      // CVPbkContactLinkArray

#include <MVPbkContactLink.h>           // MVPbkContactLink

// User includes

#include "PdcVCardImporter.h"

#include "pdclogger.h"

// Constants

_LIT( KVCardWildCard, "*.vcf" ); // Wild card extension for vCards

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CPdcVCardImporter::NewL

// Symbian 1st phase constructor

// @param    aFs     file system

// @param    aContactStore   contacts manager

// @param    aContactStore   contacts store

// @param    aLinkArray  links to contacts added.

// @return a CPdcVCardImporter object.

// ---------------------------------------------------------------------------

//

CPdcVCardImporter* CPdcVCardImporter::NewL( RFs& aFs,

                                        CVPbkContactManager& aContactManager,

                                        MVPbkContactStore& aContactStore,

                                        CVPbkContactLinkArray& aLinkArray )

    {

    CPdcVCardImporter* self = new( ELeave ) CPdcVCardImporter( aFs,

            aContactStore, aLinkArray );

    CleanupStack::PushL( self );

    self->ConstructL( aContactManager ); 

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::~CPdcVCardImporter

// Destructor

// ---------------------------------------------------------------------------

//

CPdcVCardImporter::~CPdcVCardImporter()

    {

    delete iVCardEngine;

    delete iFileDirectory;

    delete iImportOperation;

    delete iVCardList;

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::CPdcVCardImporter

// C++ constructor

// @param    aFs     file system

// @param    aContactStore   contacts store

// @param    aLinkArray  links to contacts added.

// ---------------------------------------------------------------------------

//

CPdcVCardImporter::CPdcVCardImporter( RFs& aFs,

                                          MVPbkContactStore& aContactStore,

                                          CVPbkContactLinkArray& aLinkArray )

    : CActive( EPriorityNormal),

      iContactStore( aContactStore ),

      iFs( aFs ),

      iLinkArray( aLinkArray )

    {

    }

// ---------------------------------------------------------------------------

//  CPdcXmlImporter::ConstructL

//  Second-phase constructor

//  @param    aContactManager   contacts manager

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::ConstructL( CVPbkContactManager& aContactManager )

    {

    iVCardEngine = CVPbkVCardEng::NewL( aContactManager );

    CActiveScheduler::Add( this );

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::GetVCardsL  

//  Starts the syncronously importation of all the vCards in the 

//  given directory.

//  @param    aFileDirectory    directory containg vCards.

//  @param    aCallerStatus   caller's TRequestStatus

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::GetVCardsL(const TDesC& aFileDirectory,

                                     TRequestStatus& aCallerStatus )

    {

    LOGTEXT(_L("CPdcVCardImporter::GetVCardsL"));

    aCallerStatus = KRequestPending;

    // Get list of vCards in directory

    TFindFile fileFinder( iFs );

    TInt error = fileFinder.FindWildByDir( KVCardWildCard, 

                                                    aFileDirectory, iVCardList);

    // Find the number of vCards in the directory

    if ( error == KErrNotFound )

        {

        // If the are no vCards in the directory, complete the

        // caller status

        TRequestStatus* s = &aCallerStatus;

		User::RequestComplete( s, KErrNone );

        }

    else

        {

        // Store the callers TRequestStatus

        iCallerStatus = &aCallerStatus;

        // Store the directory

        iFileDirectory = aFileDirectory.AllocL();

        // Start reading in the vCards.

        SelfComplete();

        }

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::ImportContactsL

// Imports the contacts contained within a vCard.

// @param   aFileName filename of vCard to import

// ---------------------------------------------------------------------------

//  

void CPdcVCardImporter::ImportContactsL( const TDesC& aFileName )

    {

    LOGTEXT(_L("CPdcVCardImporter::ImportContactsL"));

    // Create the full path to the vCard (Note: TParse uses a TBuf<256)

    // internally ).

    TParse fileAndPath;

    fileAndPath.Set( aFileName, iFileDirectory, NULL );

    const TDesC& fullName = fileAndPath.FullName();

    // open the vCard into a file stream

    RFileReadStream vCard;

	User::LeaveIfError( vCard.Open( iFs, fullName, EFileRead ) );

	CleanupClosePushL( vCard );

    // Import the vCard into the contacts database

    iImportOperation = iVCardEngine->ImportVCardL(

            iContactStore, vCard , *this );

	// Cleanup

	CleanupStack::PopAndDestroy(); // vCard

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::SelfComplete

// Signals that the AO should be run again by completing the outstanding

// TRequestStatus.

// ---------------------------------------------------------------------------

//  

void CPdcVCardImporter::SelfComplete()

    {

    LOGTEXT(_L("CPdcVCardImporter::SelfComplete"));

    // Begin the process of adding of the prefined contacts to contacts

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive(); 

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::DoCancel

// From CActive

// Completes the caller's TRequestStatus with KErrCancel

// ---------------------------------------------------------------------------

//  

void CPdcVCardImporter::DoCancel()

    {

    delete iImportOperation;

    iImportOperation = NULL;

    // If the vCard importer is cancelled, we need to complete the

    // callers TRequestStatus.

    User::RequestComplete( iCallerStatus, KErrCancel );

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::RunL

// From CActive

// When the request is completed, the next vCard is imported. 

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::RunL()

    {

    // Import the vCard

    const TDesC& fileName = (*iVCardList)[iVCardIndex].iName;

    ImportContactsL( fileName );

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::RunError

// From CActive

// If RunL leaves, the caller's TRequestStatus is completed with the error.

// ---------------------------------------------------------------------------

//

TInt CPdcVCardImporter::RunError( TInt aError )

    {

    LOGTEXT(_L("CPdcVCardImporter::RunError"));

    // Report the error to the caller of the getVcards function by 

    // completing the callers activeObject.

    User::RequestComplete( iCallerStatus, aError );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::AddToLinkArray

// Creates copies of contact links and adds them to the contact array.

// @param   aResults array of links to the contacts items that have been 

//                   added.

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::AddToLinkArrayL( const MVPbkContactLinkArray& aResults)

    {

    // Store the links that have been added. A MVPbkContactLinkArray array

    // is read-only so copies of the links need to be made and added

    // to iLinkArray.

    TInt linkCount = aResults.Count();

    for ( TInt index = 0; index < linkCount; index++ )

        {

        const MVPbkContactLink& link = aResults[index];

        MVPbkContactLink* copiedLink = link.CloneLC();

        iLinkArray.AppendL( copiedLink );

        CleanupStack::Pop(); // copiedLink 

        }

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::ContactsSaved

// from MVPbkContactCopyObserver

// Called when the contact has been successfully commited. If any contacts are 

// created links to them are added to the link array. The next vCard is then 

// queued for importing, if there are no more vCards to add, the caller's 

// TRequestStatus is completed.

//

// @param aOperation    The operation that this observer monitors.

// @param aResults  An array of links to copied contacts.

//                  Caller takes the ownership of the 

//                  object immediately.

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::ContactsSaved( 

        MVPbkContactOperationBase& /*aOperation*/,

        MVPbkContactLinkArray* aResults )

    {

    LOGTEXT(_L("CPdcVCardImporter::ContactsSaved"));

    delete iImportOperation;

    iImportOperation = NULL;

    if ( aResults )

        {

        // Store any links

        TRAP_IGNORE( AddToLinkArrayL( *aResults ) )

        // delete the results array

        delete aResults;

        }

    // Increase the index

    iVCardIndex++;

    // If last vCard has been imported,  

    // inform the caller or self complete to import the next vCard.

    if ( iVCardIndex < iVCardList->Count() )

        {

        SelfComplete();

        }

    else

        {

        User::RequestComplete( iCallerStatus, KErrNone );

        }

    }

// ---------------------------------------------------------------------------

// CPdcVCardImporter::

// from MVPbkContactCopyObserver

// Called when there was en error while saving contact(s).

// @param aOperation    The operation that this observer monitors.

// @param aError an error that occured.

// ---------------------------------------------------------------------------

//

void CPdcVCardImporter::ContactsSavingFailed( 

        MVPbkContactOperationBase& /*aOperation*/, TInt aError )

    {

    LOGTEXT2(_L("CPdcVCardImporter::ContactsSavingFailed aError = %d"), aError);

    // If last vCard has been handled, inform the caller or self complete to 

    // import the next vCard.   

    User::RequestComplete( iCallerStatus, aError );

    }