esimitemengine.cpp

基于SIP协议的即时消息聊天功能设计,Symbian平台下实现

/*
============================================================================
 Name        : ESIMItemEngine.cpp
 Author      : 
 Version     :
 Copyright   : Your copyright notice
 Description : ESIMItemEngine.cpp - source file
============================================================================
*/

// INCLUDE FILES
#include <s32file.h>
#include <e32std.h>
#include <aknquerydialog.h> 
#include <stringloader.h>
#include "ESIMUserItem.h"
#include "ESIMGroupItem.h"
#include "ESIMUserItemForm.h"
#include "ESIMGroupItemForm.h"

#include "ESIMItemEngine.h"
#include "ESIMAppui.h"
#include  <ESIM.rsg>	
#include  <ESIM.hrh>

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

// ---------------------------------------------------------
// CESIMItemEngine::NewL()
// Creates an instance of the CESIMItemEngine class.
// ---------------------------------------------------------
//
CESIMItemEngine* CESIMItemEngine::NewL()
    {
    CESIMItemEngine* self = CESIMItemEngine::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------
// CESIMUserItem::NewLC()
// Creates an instance of the CESIMUserItem class.
// ---------------------------------------------------------
//
CESIMItemEngine* CESIMItemEngine::NewLC()
    {
    CESIMItemEngine* self = new ( ELeave ) CESIMItemEngine;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------
// CESIMItemEngine::CESIMItemEngine()
// constructor
// ---------------------------------------------------------
//
CESIMItemEngine::CESIMItemEngine()
    {
	iCurrentGroupIndex = -1;
    }

// ---------------------------------------------------------
// CESIMItemEngine::ConstructL()
// Two phased constructor
// ---------------------------------------------------------
//
void CESIMItemEngine::ConstructL( )
    {
    }

// ---------------------------------------------------------
// CESIMItemEngine::~CESIMItemEngine ()
// Destructor
// ---------------------------------------------------------
//
CESIMItemEngine::~CESIMItemEngine()
    {
		iUserItemList.ResetAndDestroy();
		iGroupItemList.ResetAndDestroy();
    }

// ---------------------------------------------------------
// CESIMItemEngine::UserItemList()
// return The list of userinfo items
// ---------------------------------------------------------
// 
RPointerArray<CESIMUserItem>& CESIMItemEngine::UserItemList()
    {
    return iUserItemList;
    }

// ---------------------------------------------------------
// CESIMItemEngine::GroupItemList()
// return The list of groupinfo items
// ---------------------------------------------------------
// 
RPointerArray<CESIMGroupItem>& CESIMItemEngine::GroupItemList()
    {
    return iGroupItemList;
    }

// ---------------------------------------------------------
// CESIMItemEngine::UserItem( TInt aIndex )
// ---------------------------------------------------------
//
CESIMUserItem* CESIMItemEngine::UserItem( TInt aIndex )
	{		
    CESIMUserItem* item = static_cast<CESIMUserItem*>( iUserItemList[aIndex] );
	return item;
	}

// ---------------------------------------------------------
// CESIMItemEngine::GroupItem( TInt aIndex )
// ---------------------------------------------------------
//
CESIMGroupItem* CESIMItemEngine::GroupItem( TInt aIndex )
	{		
    CESIMGroupItem* item = static_cast<CESIMGroupItem*>( iGroupItemList[aIndex] );
	return item;
	}

// ----------------------------------------------------
// CESIMItemEngine::InsertUserItemL( CESIMUserItem* aItem, TInt aIndex )
// ----------------------------------------------------
//
void CESIMItemEngine::InsertUserItemL( CESIMUserItem* aItem, TInt aIndex )
    {
    User::LeaveIfError( iUserItemList.Insert( aItem, aIndex )  );
    }

// ----------------------------------------------------
// CESIMItemEngine::InsertGroupItemL( CESIMGroupItem* aItem, TInt aIndex )
// ----------------------------------------------------
//
void CESIMItemEngine::InsertGroupItemL( CESIMGroupItem* aItem, TInt aIndex )
    {
    User::LeaveIfError( iGroupItemList.Insert( aItem, aIndex )  );
    }

// ----------------------------------------------------
//CESIMItemEngine::RemoveUserItem( TInt aIndex )
// ----------------------------------------------------
//
void CESIMItemEngine::RemoveUserItem( TInt aIndex )
    {
	CESIMUserItem* item = static_cast<CESIMUserItem*>( iUserItemList[aIndex] );
	iUserItemList.Remove( aIndex );
	delete item;
    }

// ----------------------------------------------------
//CESIMItemEngine::RemoveGroupItem( TInt aIndex )
// ----------------------------------------------------
//
void CESIMItemEngine::RemoveGroupItem( TInt aIndex )
    {
	CESIMGroupItem* item = static_cast<CESIMGroupItem*>( iGroupItemList[aIndex] );
	iGroupItemList.Remove( aIndex );
	delete item;
    }

// ----------------------------------------------------
// CESIMItemEngine::UserItemCount()
// ----------------------------------------------------
// 
TInt CESIMItemEngine::UserItemCount()
	{
	return iUserItemList.Count();
    }

// ----------------------------------------------------
// CESIMItemEngine::GroupItemCount()
// ----------------------------------------------------
// 
TInt CESIMItemEngine::GroupItemCount()
	{
	return iGroupItemList.Count();
    }

// ----------------------------------------------------
// CESIMItemEngine::ExternalizeL( RWriteStream& aStream, CStreamDictionary& aStreamDic ) const
// ----------------------------------------------------
// 
void CESIMItemEngine::ExternalizeL( CStreamStore& aStore, CStreamDictionary& aStreamDic, TUid appUid ) const
	{
	RStoreWriteStream stream;

	TStreamId id = stream.CreateLC( aStore );

	UserWriteL(stream);

	GroupWriteL(stream);

	stream.CommitL();

	aStreamDic.AssignL( appUid, id );//Application()->AppDllUid()
	CleanupStack::PopAndDestroy(); // stream
    }

// ----------------------------------------------------
// CESIMItemEngine::UserWriteL( RWriteStream& aStream, RPointerArray<CESIMUserItem>& aUserItemList) const
// ----------------------------------------------------
// 
void CESIMItemEngine::UserWriteL( RWriteStream& aStream) const
	{
	TInt count = iUserItemList.Count();

	aStream.WriteInt16L( static_cast<TInt16>( count ) );

	for ( TInt index = 0; index < count; ++index )
	{
		( static_cast<CESIMUserItem*>( iUserItemList[index] ) )->
			ExternalizeL( aStream );
	}
    }

// ----------------------------------------------------
// CESIMItemEngine::GroupWriteL( RWriteStream& aStream, CStreamDictionary& aStreamDic ) const
// ----------------------------------------------------
// 
void CESIMItemEngine::GroupWriteL( RWriteStream& aStream ) const
	{
	TInt count = iGroupItemList.Count();
	
	aStream.WriteInt16L(static_cast<TInt16>( count ));

	for (TInt index = 0; index < count; ++index)
	{
		(static_cast<CESIMGroupItem*>(iGroupItemList[index]))->
			ExternalizeL(aStream);
	}
    }

// ----------------------------------------------------
// CESIMItemEngine::InternalizeL( RReadStream& aStream, CStreamDictionary& aStreamDic )
// ----------------------------------------------------
// 
void CESIMItemEngine::InternalizeL( const CStreamStore& aStore, const CStreamDictionary& aStreamDic, TUid appUid )
	{
	TStreamId id = aStreamDic.At( appUid );//Application()->AppDllUid()
	RStoreReadStream stream;
	stream.OpenLC( aStore, id );

	UserReadL(stream);
	GroupReadL(stream);

	/*TInt count = stream.ReadInt16L();
	for ( TInt index = 0; index < count; ++index )
	{
		CLinkmanItem* item = CLinkmanItem::NewL();
		CleanupStack::PushL( item );
		item->InternalizeL( stream );
		User::LeaveIfError( iItemList.Append( item ) );
		CleanupStack::Pop( item );
	}*/

	CleanupStack::PopAndDestroy();  // stream
    }

// ----------------------------------------------------
// CESIMItemEngine::UserReadL( RWriteStream& aStream )