/*
* Copyright (c) 2002-2006 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:  Base class for app servers
*
*/



// INCLUDE FILES
#include <badesca.h>
#include <s32mem.h>
#include <AiwGenericParam.h>

#include "CNewFileServiceBase.h"
#include "NewFileServiceDefs.h"

// CONSTANTS
const TInt KFilenameArrayGranularity( 2 );


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

// ---------------------------------------------------------------------------
// CNewFileServiceBase::CNewFileServiceBase
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
EXPORT_C CNewFileServiceBase::CNewFileServiceBase():iError(0)
    {
    }


// ---------------------------------------------------------------------------
// CNewFileServiceBase::~CNewFileServiceBase
//
// ---------------------------------------------------------------------------
//
// Destructor
EXPORT_C CNewFileServiceBase::~CNewFileServiceBase()
    {
	delete iFilenameArray;
	delete iGenericParams;
    }


// ---------------------------------------------------------------------------
// CNewFileServiceBase::DeserializeGenericParamsL
//
// ---------------------------------------------------------------------------
//
void CNewFileServiceBase::DeserializeGenericParamsL( const RMessage2& aMessage )
	{
	if ( !iGenericParams )
		{
		iGenericParams = CAiwGenericParamList::NewL();
		}
	else
		{
		iGenericParams->Reset();
		}

	TInt dataLength( aMessage.GetDesLengthL( ENewServiceIndexFileName ) );
	if ( dataLength == 0 )
		{
		return;
		}

	HBufC8* buffer = HBufC8::NewLC( dataLength );
	TPtr8 ptr( buffer->Des() );
	aMessage.ReadL( ENewServiceIndexFileName, ptr );

	RDesReadStream stream( ptr );
	iGenericParams->InternalizeL( stream );
	CleanupStack::PopAndDestroy();   // buffer
	}


// ---------------------------------------------------------------------------
// CNewFileServiceBase::ServiceL
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CNewFileServiceBase::ServiceL( const RMessage2& aMessage )
	{
#ifdef _DEBUG
	RDebug::Print( _L("CNewFileServiceBase::ServiceL %d"), 
			aMessage.Function() );
#endif
	switch ( aMessage.Function() )
		{
			case ECreateNewFile:
				{
				TPckgBuf< TNewServiceParamPack > paramPack;
				aMessage.ReadL( ENewServiceIndexParams, paramPack );

				if ( !iFilenameArray )
					{
					iFilenameArray = new ( ELeave )
						CDesCArrayFlat( KFilenameArrayGranularity );
					}
				iFilenameArray->Reset();

				DeserializeGenericParamsL( aMessage );

				// Copy the message handle so we can reply to the message when
				// the service observer gets called
				iPendingMessage = aMessage;

				HandleNewFileL( this, *iFilenameArray, paramPack().iType, 
								paramPack().iMultipleFiles );

    			break;
				}

			case ENewFileToHandle:
				{
				TPckgBuf< TNewServiceParamPack > paramPack;
				aMessage.ReadL( ENewServiceIndexParams, paramPack );

				DeserializeGenericParamsL( aMessage );

				// Adopt file handle from client
				RFile file;
				TInt err = file.AdoptFromClient( aMessage, 
												 ENewServiceIndexFsHandle, 
												 ENewServiceIndexFileHandle );
#ifdef _DEBUG
				RDebug::Print( _L("adopt error: %d" ), err );
#endif
				// Copy the message handle so we can reply to the message when
				// the service observer gets called
				iPendingMessage = aMessage;

				HandleNewFileL( this, file, paramPack().iType );

				break;
				}

			case EGetFilenameArrayLength:
				{
				// Calculate the size of the buffer needed to transfer the 
				//filenames to the client side
				TPckgBuf< TInt > lengthBuf;
				TInt count( iFilenameArray->MdcaCount() );
#ifdef _DEBUG
				RDebug::Print( _L("Filename array count: %d"), count );
#endif
				TInt length = sizeof( TInt ) + count * sizeof( TUint16 );
				for ( TInt i( 0 ); i < count; i++ )
					{
					length += iFilenameArray->MdcaPoint( i ).Size();
					}

				lengthBuf = length;
				aMessage.WriteL( ENewServiceIndexParams, lengthBuf );
				aMessage.Complete( KErrNone );
				break;
				}

			case EGetFilenameArray:
				{
				// Allocate a buffer with the same size as in the client side
				TInt length( aMessage.GetDesMaxLengthL( ENewServiceIndexParams ) );
				HBufC8* buffer = HBufC8::NewLC( length );

				TPtr8 ptr = buffer->Des();
				RDesWriteStream stream( ptr );

				// Stream the filename array to the buffer
				TInt count( iFilenameArray->MdcaCount() );
				stream.WriteInt32L( count );
				for ( TInt i( 0 ); i < count; i++ )
					{
					TPtrC filename = iFilenameArray->MdcaPoint( i );
					stream.WriteUint16L( filename.Length() );
					stream.WriteL( filename );
					}

				stream.CommitL();

				// Return the buffer to the client side
				aMessage.WriteL( ENewServiceIndexParams, ptr );
				aMessage.Complete( KErrNone );
				CleanupStack::PopAndDestroy();	// buffer

				// notify the application that the transfer is complete and
				// it's ok to quit / whatever
				ServiceCompleteL();

				break;
				}
			default:
			    {
			    // Complete old message if still open
                if ( !iPendingMessage.IsNull() )
                    {
                    iPendingMessage.Complete( KErrCancel );	
                    }

				CApaAppServiceBase::ServiceL(aMessage);
				break;
			    }
		}
	}


// ---------------------------------------------------------------------------
// CNewFileServiceBase::HandleCompletedNewServiceL
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CNewFileServiceBase::HandleCompletedNewServiceL( 
														TBool aReturnValue )
	{
	// Message was already completed in ServiceL
	if ( iPendingMessage.IsNull() )
	    {
	    return;
	    }

	TNewServiceParamPack pack;
	TPckgBuf< TNewServiceParamPack > paramPack;
	pack.iReturnValue = aReturnValue;
	paramPack = pack;

	iPendingMessage.WriteL( ENewServiceIndexParams, paramPack );
    if(iError != KErrAbort)
    	{
  	    iPendingMessage.Complete( KErrNone );
    	}
    else
    	{
  	    iPendingMessage.Complete( KErrAbort );
  	    iError = 0;    		
    	}
	}


// ---------------------------------------------------------------------------
// CNewFileServiceBase::GenericParams
//
// ---------------------------------------------------------------------------
//
EXPORT_C CAiwGenericParamList* CNewFileServiceBase::GenericParams()
	{
	return iGenericParams;
	}
	

// ---------------------------------------------------------------------------
// CNewFileServiceBase::GenericParams
//
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CNewFileServiceBase::GetErrorCode()
	{
	return iError;
	}
	
	
// ---------------------------------------------------------------------------
// CNewFileServiceBase::GenericParams
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CNewFileServiceBase::SetErrorCode(TInt aError)
	{
    iError = aError;
	}	


//  End of File