/*

* Copyright (c) 2008-2010 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:  Contacts Group object conversion routines

*

*/

// INCLUDES

#include <utf.h>

#include <cntdef.h>

#include <cntitem.h>

#include <cntfldst.h>

#include <vcard.h>

#include <vprop.h> 

#include <vutil.h>

#include <s32mem.h>

#include "contactsgrpconverter.h"

#include "logger.h"

// CONSTANTS

/*

vCard format example:

BEGIN:VCARD

VERSION:2.1

FN:GroupName

X-CNTGRP:4;14;54

END:VCARD

*/

// Group label property

_LIT8(KCntGrpFN, "FN");

// Group contacts propetry

_LIT8(KCntGrpXCntGrp, "X-CNTGRP");

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

// CContactsGrpConverter::NewL

// Two-phased constructor.

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

CContactsGrpConverter* CContactsGrpConverter::NewL()

    {

    CContactsGrpConverter* self = CContactsGrpConverter::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CContactsGrpConverter::NewLC

// Two-phased constructor.

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

CContactsGrpConverter* CContactsGrpConverter::NewLC()

    {

    TRACE_FUNC_ENTRY;

    CContactsGrpConverter* self = new (ELeave) CContactsGrpConverter();

    CleanupStack::PushL( self );

    self->ConstructL();

    TRACE_FUNC_EXIT;

    return self;

    }

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

// CContactsGrpConverter::CContactsGrpConverter

// C++ default constructor can NOT contain any code, that might leave

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

CContactsGrpConverter::CContactsGrpConverter()

    {

    }

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

// CContactsGrpConverter::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CContactsGrpConverter::ConstructL()

    {

    ResetL();

    }

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

// CContactsGrpConverter::~CContactsGrpConverter

// Destructor.

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

CContactsGrpConverter::~CContactsGrpConverter()

    {

    TRACE_FUNC_ENTRY;

    delete iContactsIdArray;

    delete iGroupLabel;

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::GroupLabel

// returns group label

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

const TDesC& CContactsGrpConverter::GroupLabel() const

    {

    return *iGroupLabel;

    }

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

// CContactsGrpConverter::ItemsContained

// returns contact items belonging to this group

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

const CContactIdArray& CContactsGrpConverter::ItemsContained() const

    {

    return *iContactsIdArray;

    }

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

// CContactsGrpConverter::ImportDbItemL

// Imports group item

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

void CContactsGrpConverter::ImportDbItemL( CContactGroup& aItem )

    {

    TRACE_FUNC_ENTRY;

    if ( aItem.Type() != KUidContactGroup )

        {

        User::Leave( KErrNotSupported );

        }

    ResetL();

    if ( aItem.HasItemLabelField() )

        {

        TPtrC label = aItem.GetGroupLabelL();

        delete iGroupLabel;

        iGroupLabel = NULL;

        iGroupLabel = label.AllocL();

        }

    else

        {

        delete iGroupLabel;

        iGroupLabel = NULL;

        iGroupLabel = KNullDesC().AllocL();

        }

    // this is NULL, if no items

    CContactIdArray* tempIdArray = aItem.ItemsContainedLC();

    if ( tempIdArray )

        {

        delete iContactsIdArray;

        iContactsIdArray = tempIdArray;

        CleanupStack::Pop( tempIdArray );

        }

    LOGGER_WRITE_1("GroupName: %S", iGroupLabel);

    if ( iContactsIdArray )

        {

        LOGGER_WRITE_1("contacts count: %d", iContactsIdArray->Count() );

        }

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::ExportVCardL

// Export contact group as vCard

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

void CContactsGrpConverter::ExportVCardL( CBufBase& aBuffer )

    {

    TRACE_FUNC_ENTRY;

    RBufWriteStream stream( aBuffer, 0);

    CleanupClosePushL( stream );

    ExportVCardL( stream );

    CleanupStack::PopAndDestroy( &stream );

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::ExportL

// Exports contact group as to vCard

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

void CContactsGrpConverter::ExportVCardL( RWriteStream& aWriteStream )

    {

    TRACE_FUNC_ENTRY;

    CParserVCard* vCardParser = CParserVCard::NewL();

    CleanupStack::PushL( vCardParser );

    // add group name

    CParserPropertyValue* FNvalue = CParserPropertyValueHBufC::NewL( *iGroupLabel );

    // Associate the property params and property value with the FN property

    CParserProperty* FNproperty=CParserProperty::NewL( *FNvalue, KCntGrpFN, NULL );

    // Finally add the FN property to the vCard using the parser object.

    vCardParser->AddPropertyL( FNproperty );

    // add group contacts

    const TInt KDefaultGranularity = 5;

    CDesCArrayFlat* flatArray = new (ELeave) CDesCArrayFlat(KDefaultGranularity);

    CleanupStack::PushL( flatArray );

    TInt count = iContactsIdArray->Count();

    const TInt KMaxIdLength = 10;

    TBuf<KMaxIdLength> idnum;

    for ( TInt i=0; i<count; i++ )

        {

        const TContactItemId id = (*iContactsIdArray)[i];

        idnum.Zero();

        idnum.AppendNum( id );

        flatArray->AppendL( idnum );

        }

    CParserPropertyValueCDesCArray* grPropertyValueArray =

        new (ELeave) CParserPropertyValueCDesCArray( flatArray );

    CleanupStack::Pop( flatArray );

    CParserProperty* grProperty = 

        CParserProperty::NewL( *grPropertyValueArray, KCntGrpXCntGrp, NULL );

    vCardParser->AddPropertyL( grProperty );

    // Set default sharacterset

    vCardParser->SetDefaultCharSet( Versit::EUTF8CharSet );

    vCardParser->ExternalizeL( aWriteStream );

    CleanupStack::PopAndDestroy( vCardParser );

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::ImportVCardL

// Import vCard item

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

void CContactsGrpConverter::ImportVCardL( const TDesC8& aBuffer )

    {

    TRACE_FUNC_ENTRY;

    ResetL();

    CParserVCard* vCardParser = CParserVCard::NewL();

    vCardParser->SetDefaultCharSet( Versit::EUTF8CharSet );

    CleanupStack::PushL( vCardParser );

    RDesReadStream stream( aBuffer );

    vCardParser->InternalizeL( stream ); // To import a vCard.

    stream.Close(); // Close the file stream once the import is done.

    CArrayPtr<CParserProperty>* properties = vCardParser->ArrayOfProperties( EFalse );

    LOGGER_WRITE_1("properties count: %d", properties->Count());

    for (TInt i=0; i<properties->Count(); i++)

        {

        const CParserProperty* property = properties->At(i);

        // FN

        if ( property->Name() == KCntGrpFN )

            {

            LOGGER_WRITE("group name found");

            delete iGroupLabel;

            iGroupLabel = NULL;

            CParserPropertyValue* pvalue = property->Value();

            TPtrC val = (static_cast<CParserPropertyValueHBufC*> (pvalue))->Value();

            iGroupLabel = val.AllocL();

            LOGGER_WRITE_1("iGroupLabel: %S", iGroupLabel);

            }

        // X-CNTGRP

        else if ( property->Name() == KCntGrpXCntGrp )

            {

            LOGGER_WRITE("group contacts found");

            CParserPropertyValue* pvalue = property->Value();

            TPtrC val = (static_cast<CParserPropertyValueHBufC*> (pvalue))->Value();

            SetContactItemsL( val );

            }

        else

            {

            // skip other properties

            }

        }

    CleanupStack::PopAndDestroy( vCardParser );

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::ResetL

// Reset all data

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

void CContactsGrpConverter::ResetL()

    {

    delete iGroupLabel;

    iGroupLabel = NULL;

    iGroupLabel = KNullDesC().AllocL();

    if ( iContactsIdArray )

        {

        iContactsIdArray->Reset();

        }

    else

        {

        iContactsIdArray = CContactIdArray::NewL();

        }

    }

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

// CContactsGrpConverter::SetContactItemsL

// Parses contact items from aValue

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

void CContactsGrpConverter::SetContactItemsL( const TDesC& aValue )

    {

    TRACE_FUNC_ENTRY;

    const TInt KDefaultGranularity = 5;

    RArray<TPtrC> arr(KDefaultGranularity);

    CleanupClosePushL( arr );

    const TChar separator(';');

    SplitL( aValue, separator, arr );

    if ( iContactsIdArray )

        {

        iContactsIdArray->Reset();

        }

    else

        {

        iContactsIdArray = CContactIdArray::NewL();

        }

    for (TInt i=0; i<arr.Count(); i++ )

        {

        TLex lex( arr[i] );

        TInt32 id;

        TInt err = lex.Val( id );

        if ( err )

            {

            LOGGER_WRITE_1("lex.val returned err: %d, leaving with KErrCorrupt", err);

            iContactsIdArray->Reset();

            User::Leave( KErrCorrupt );

            }

        LOGGER_WRITE_1("add: %d", id);

        iContactsIdArray->AddL( id );

        }

    CleanupStack::PopAndDestroy( &arr );

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::SplitL

// Function splits string (eg "name1, name2, name3") into substrings.

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

void CContactsGrpConverter::SplitL(const TDesC& aText, const TChar aSeparator, 

                    RArray<TPtrC>& aArray)

    {

    TRACE_FUNC_ENTRY;

    TPtrC ptr;

    ptr.Set(aText);

    for (;;)

        {

        TInt pos=ptr.Locate(aSeparator);

        if (pos==KErrNotFound)

            {

            TrimAll( ptr );

            if ( ptr.Length() > 0 )

                {

                aArray.AppendL(ptr);

                }

            break;

            }

        TPtrC subStr=ptr.Left(pos); // get pos characters starting from position 0

        TrimAll( subStr );

        if ( subStr.Length() > 0 )

            {

            aArray.AppendL(subStr);

            }

        if ( !(ptr.Length()>pos+1) )

            {

            break;

            }

        ptr.Set( ptr.Mid(pos+1) ); // get all characters starting from position pos+1

        }

    TRACE_FUNC_EXIT;

    }

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

// CContactsGrpConverter::TrimAll

// Trims all whitespaces from beginning and end of string

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

void CContactsGrpConverter::TrimAll( TPtrC& aValue )

    {

    TRACE_FUNC_ENTRY;

    TInt valueStart(0);

    while ( valueStart < aValue.Length() 

            && (aValue[valueStart] == ' '

            || aValue[valueStart] == '\r'

            || aValue[valueStart] == '\n') )

        {

        valueStart++;

        }

    TInt valueEnd(aValue.Length()-1);

    while ( valueEnd > 0 

            && (aValue[valueEnd] == ' '

            || aValue[valueEnd] == '\r'

            || aValue[valueEnd] == '\n') )

        {

        valueEnd--;

        }

    valueEnd++;

    aValue.Set( aValue.Mid(valueStart, valueEnd - valueStart));

    TRACE_FUNC_EXIT;

    }