/*
* 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
// -----------------------------------------------------------------------------
//
EXPORT_C void CCAGroup::ExternalizeL( RWriteStream& aStream ) const
{
// integers etc.
aStream.WriteInt8L( ( TInt8 ) iIsOwnGroup ); // TBool
// Descriptors are externalized as length-data pairs
ExternalizeBufferToStreamL( iGroupId, aStream );
CHAT_DP( D_CHAT_LIT( "CCAGroup::ExternalizeL - Group id: %S" ), iGroupId );
ExternalizeBufferToStreamL( iGroupName, aStream );
CHAT_DP( D_CHAT_LIT( "CCAGroup::ExternalizeL - Group name: %S" ),
iGroupName );
ExternalizeBufferToStreamL( iServerName, aStream );
CHAT_DP( D_CHAT_LIT( "CCAGroup::ExternalizeL - Group server: %S" ),
iServerName );
}
// -----------------------------------------------------------------------------
// CCAGroup::InternalizeL
// From MCAExtendedStoredGroup
// -----------------------------------------------------------------------------
//
EXPORT_C void CCAGroup::InternalizeL( RReadStream& aStream )
{
// default values are set in the 2nd phase constructor ConstructL
// integers etc.
iIsOwnGroup = aStream.ReadInt8L(); // TBool
// descriptors
// group id
HBufC* tempGroupId = InternalizeBufferFromStreamL( aStream );
CleanupStack::PushL( tempGroupId );
HBufC* tempGroupName = InternalizeBufferFromStreamL( aStream );
CleanupStack::PushL( tempGroupName );
HBufC* tempServerName = InternalizeBufferFromStreamL( aStream );
CleanupStack::Pop( tempGroupName );
CleanupStack::Pop( tempGroupId );
delete iGroupId;
iGroupId = tempGroupId;
CHAT_DP( D_CHAT_LIT( "CCAGroup::InternalizeL - Group id: %S" ), iGroupId );
// group name
delete iGroupName;
iGroupName = tempGroupName;
CHAT_DP( D_CHAT_LIT( "CCAGroup::InternalizeL - Group name: %S" ),
iGroupName );
// server name
delete iServerName;
iServerName = tempServerName;
CHAT_DP( D_CHAT_LIT( "CCAGroup::InternalizeL - Group server: %S" ),
iServerName );
// CDesCArrays
// members
iMembers->Reset();
// participants
iParticipants->Reset();
// must set saved flag
SetStorageType( TStorageManagerGlobals::EStoragePersistent );
// set non-visible flag (set this when you want UI to see this)
SetVisible( ETrue );
// we have changed
iIsChanged |= 1;
}
// -----------------------------------------------------------------------------
// CCAGroup::MaximalSize
// From MCAExtendedStoredGroup
// When changing Externalize/Internalize, be sure to update this method too.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt32 CCAGroup::MaximalSize() const
{
TInt len = 1; // TBool, 8 bit/1 byte
len += 4; // length of buffer (32 bit/4 byte)
len += iGroupId->Size();
len += 4; // length of buffer (32 bit/4 byte))
len += iGroupName->Size();
len += 4; // length of buffer (32 bit/4 byte))
len += iServerName->Size();
return len;
}
// -----------------------------------------------------------------------------
// CCAGroup::Version
// From MCAExtendedStoredGroup
// -----------------------------------------------------------------------------
//
EXPORT_C TInt32 CCAGroup::Version() const
{
return KCAGroupVersion;
}
// End of File