/*

* Copyright (c) 2003-2005 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:  Implementation of contact data container

*

*/

// INCLUDE FILES

#include "CCAGroup.h"

#include "CCAStorage.h"

#include "TCAStoragePanics.h"

#include "TStorageManagerGlobals.h"

#include "MCAStoredGroupsObserver.h"

#include <e32base.h>

#include <e32std.h>

#include <e32def.h>

#include <s32strm.h>

#include "ChatDebugPrint.h"

// CLASS FORWARD declarations

// CONSTANTS

const TInt KCAGroupArrayGranularity = 5; // estimated

//LOCAL FUNCTIONS

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

// ExternalizeBufferToStreamL

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

//

void ExternalizeBufferToStreamL( const HBufC* aBuffer, RWriteStream& aStream )

    {

    if ( aBuffer )

        {

        if ( aBuffer->Length() != 0 )

            {

            aStream.WriteInt32L( aBuffer->Length() );

            aStream.WriteL( *aBuffer );

            return;

            }

        }

    // no buffer or buffer length is zero, writing length information as 0

    aStream.WriteInt32L( 0 );

    }

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

// InternalizeBufferFromStreamL

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

//

HBufC* InternalizeBufferFromStreamL( RReadStream& aStream )

    {

    HBufC* buffer = NULL;

    TInt length( aStream.ReadInt32L() );

    if ( length != 0 )

        {

        buffer = HBufC::NewLC( length );

        TPtr ptr( buffer->Des() );

        aStream.ReadL( ptr, length );

        CleanupStack::Pop( buffer ); //buffer

        }

    else

        {

        // creating empty buffer with 1 byte length

        buffer = HBufC::NewL( 1 );

        }

    return buffer;

    }

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

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

// CCAGroup::CCAGroup

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

// might leave.

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

//

CCAGroup::CCAGroup( CCAStorage* aStorage,

                    MCAStoredGroupsObserver* aObserver ) :

        iStorage( aStorage ),

        iIsJoined( EFalse ),

        iIsOwnGroup( EFalse ),

        iIsVisible( ETrue ),

        iIsAdmin( EFalse ),

        iObserver( aObserver )

    {

    iStorageType = TStorageManagerGlobals::EUnknownStorageType;

    }

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

// CCAGroup::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCAGroup::ConstructL()

    {

    iMembers = new ( ELeave ) CDesCArraySeg( KCAGroupArrayGranularity );

    iParticipants = new ( ELeave ) CDesCArraySeg( KCAGroupArrayGranularity );

    // must have something inside, so might as well make it empty and length 1

    iServerName = HBufC::NewL( 1 );

    iGroupId = HBufC::NewL( 1 );

    iGroupName = HBufC::NewL( 1 );

    }

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

// CCAGroup::NewL

// Two-phased constructor.

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

//

EXPORT_C CCAGroup* CCAGroup::NewL( CCAStorage* aStorage,

                                   MCAStoredGroupsObserver* aObserver )

    {

    CCAGroup* self = new( ELeave ) CCAGroup( aStorage, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CCAGroup::~CCAGroup()

    {

    if ( iMembers )

        {

        iMembers->Reset();

        delete iMembers;

        }

    if ( iParticipants )

        {

        iParticipants->Reset();

        delete iParticipants;

        }

    delete iGroupId;

    delete iGroupName;

    delete iServerName;

    }

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

// CCAGroup::IsJoined

// From MCAStoredGroup

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

//

EXPORT_C TBool CCAGroup::IsJoined() const

    {

    return iIsJoined;

    }

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

// CCAGroup::SetJoined

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetJoined( TBool aJoinStatus )

    {

    iIsJoined = aJoinStatus;

    iIsChanged |= 1;

    }

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

// CCAGroup::MembersL

// From MCAStoredGroup

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

//

EXPORT_C void CCAGroup::GetMembersL( CDesCArray& aMemberList ) const

    {

    aMemberList.Reset();

    const TInt count( iMembers->Count() );

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

        {

        HBufC* buf = iMembers->MdcaPoint( i ).AllocL();

        CleanupStack::PushL( buf );

        aMemberList.AppendL( *buf ); // copy is made..

        CleanupStack::PopAndDestroy( buf ); // buf

        }

    }

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

// CCAGroup::AddMembersLocallyL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::AddMembersLocallyL( const MDesCArray& aMemberList )

    {

    const TInt count( aMemberList.MdcaCount() );

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

        {

        HBufC* buf = aMemberList.MdcaPoint( i ).AllocL();

        CleanupStack::PushL( buf );

        iMembers->AppendL( *buf ); // makes a copy..

        CleanupStack::PopAndDestroy( buf ); // buf

        iIsChanged |= 1;

        }

    }

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

// CCAGroup::MembersLocallyL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::RemoveMembersLocally( const MDesCArray& aMemberList )

    {

    const TInt count( aMemberList.MdcaCount() );

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

        {

        TInt pos( 0 );

        if ( iMembers->Find( aMemberList.MdcaPoint( i ),

                             pos, ECmpCollated ) == 0 )

            {

            // found it

            iMembers->Delete( pos );

            iIsChanged |= 1;

            iMembers->Compress();

            }

        }

    }

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

// CCAGroup::ResetMembersLocally

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::ResetMembersLocally()

    {

    iMembers->Reset();

    iIsChanged |= 1;

    }

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

// CCAGroup::ParticipantsL

// From MCAStoredGroup

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

//

EXPORT_C void CCAGroup::GetParticipantsL( CDesCArray& aParticipantList ) const

    {

    aParticipantList.Reset();

    const TInt count( iParticipants->Count() );

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

        {

        HBufC* buf = iParticipants->MdcaPoint( i ).AllocL();

        CleanupStack::PushL( buf );

        aParticipantList.AppendL( *buf ); // copy is made..

        CleanupStack::PopAndDestroy( buf ); // buf

        }

    }

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

// CCAGroup::AddParticipantL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::AddParticipantL( const MDesCArray& aParticipantList )

    {

    const TInt count( aParticipantList.MdcaCount() );

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

        {

        TPtrC screenName( aParticipantList.MdcaPoint( i ) );

        TInt pos( 0 );

        if ( iParticipants->Find( screenName, pos, ECmpCollated ) != 0 )

            {

            // if the participant wasn't already in group, add it

            HBufC* buf = screenName.AllocLC();

            iParticipants->AppendL( *buf ); // makes a copy..

            CleanupStack::PopAndDestroy( buf ); // buf

            iIsChanged |= 1;

            }

        }

    }

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

// CCAGroup::RemoveParticipantL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::RemoveParticipantL( const MDesCArray& aParticipantList )

    {

    const TInt count( aParticipantList.MdcaCount() );

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

        {

        TInt pos( 0 );

        if ( iParticipants->Find( aParticipantList.MdcaPoint( i ),

                                  pos, ECmpCollated ) == 0 )

            {

            // found it

            iParticipants->Delete( pos );

            iIsChanged |= 1;

            iParticipants->Compress();

            }

        }

    }

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

// CCAGroup::ResetParticipantsL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::ResetParticipantsL()

    {

    iParticipants->Reset();

    iIsChanged |= 1;

    }

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

// CCAGroup::StorageType

// From MCAStoredGroup

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

//

EXPORT_C TStorageManagerGlobals::TCAStorageType CCAGroup::StorageType() const

    {

    return iStorageType;

    }

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

// CCAGroup::SetStorageType

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetStorageType(

    TStorageManagerGlobals::TCAStorageType aType )

    {

    iStorageType = aType;

    iIsChanged |= 1;

    }

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

// CCAGroup::IsOwnGroup

// From MCAStoredGroup

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

//

EXPORT_C TBool CCAGroup::IsOwnGroup() const

    {

    return iIsOwnGroup;

    }

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

// CCAGroup::SetOwnGroup

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetOwnGroup( TBool aOwnGroupStatus )

    {

    iIsOwnGroup = aOwnGroupStatus;

    iIsChanged |= 1;

    }

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

// CCAGroup::SetGroupIdL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetGroupIdL( const TDesC& aGroupId )

    {

    HBufC* tempGroupId = aGroupId.AllocL();

    delete iGroupId;

    iGroupId = tempGroupId;

    iIsChanged |= 1;

    }

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

// CCAGroup::GroupId

// From MCAStoredGroup

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

//

EXPORT_C const TDesC& CCAGroup::GroupId() const

    {

    return *( iGroupId );

    }

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

// CCAGroup::SetGroupNameL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetGroupNameL( const TDesC& aGroupName )

    {

    HBufC* tempGroupName = aGroupName.AllocL();

    delete iGroupName;

    iGroupName = tempGroupName;

    iIsChanged |= 1;

    }

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

// CCAGroup::GroupName

// From MCAStoredGroup

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

//

EXPORT_C const TDesC& CCAGroup::GroupName() const

    {

    return *( iGroupName );

    }

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

// CCAGroup::IsAdmin

// From MCAStoredGroup

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

//

EXPORT_C TBool CCAGroup::IsAdmin() const

    {

    return iIsAdmin;

    }

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

// CCAGroup::SetAdmin

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetAdmin( const TBool aStatus )

    {

    iIsAdmin = aStatus;

    iIsChanged |= 1;

    }

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

// CCAGroup::NumParticipants

// From MCAStoredGroup

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

//

EXPORT_C TInt CCAGroup::NumParticipants() const

    {

    return iParticipants->Count();

    }

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

// CCAGroup::IsVisible

// From MCAStoredGroup

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

//

EXPORT_C TBool CCAGroup::IsVisible() const

    {

    return iIsVisible;

    }

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

// CCAGroup::IsVisible

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetVisible( const TBool aVisible )

    {

    iIsVisible = aVisible;

    iIsChanged |= 1;

    // UI needs to know about this. it's convenient to use delete event...

    if ( iGroupId->Length() > 0 )

        {

        // there's a valid group id

        if ( !iIsVisible )

            {

            // the group have been set to invisible

            // => signal observers

            iObserver->HandleDelete( *iGroupId );

            }

        }

    // otherwise we can't send observer event. we have no valid group id yet!

    }

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

// CCAGroup::Server

// From MCAStoredGroup

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

//

EXPORT_C const TDesC& CCAGroup::Server() const

    {

    return *( iServerName );

    }

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

// CCAGroup::Server

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SetServerL( const TDesC& aServer )

    {

    HBufC* tempServerName = aServer.AllocL();

    delete iServerName;

    iServerName = tempServerName;

    iIsChanged |= 1;

    }

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

// CCAGroup::SaveChangesL

// From MCAExtendedStoredGroup

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

//

EXPORT_C void CCAGroup::SaveChangesL()

    {

    TBool wasChanged( 0 != iIsChanged );

    iStorage->SaveL( this );

    iStorageType = TStorageManagerGlobals::EStoragePersistent;

    iIsChanged = 0;

    if ( wasChanged )

        {

        // Notify observer. The observer shall decide whether to pass

        // the information forward.

        iObserver->HandleChange( *iGroupId );

        }

    }

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

// CCAGroup::ExternalizeL

// From MCAExtendedStoredGroup

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

//