/*

* Copyright (c) 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:  Test support file tool

 *

*/

#include <e32std.h>

#include <f32file.h>

#include <s32file.h>

#include "prfwtestfiletool.h"

#include "prfwtestfilesrvmsg.h"

#include "ximpeventcodec.h"

#include "prfwtestfileobserver.h"

/* Hierarchy under C:/temp/prfw/:

 * /protocoluid/instancenumber/Plugin\

 * /protocoluid/instancenumber/SrvMsg\

 */

_LIT( KFileToolMainDirFull, "c:\\temp\\prfw" );

_LIT( KFileToolBackslash, "\\" );

_LIT( KFileToolDirUid, "%d" );

_LIT( KInstanceAsNumber, "%d" );

_LIT( KFileToolPluginDirBase, "Plugin" );

_LIT( KFileToolSrvDirBase, "SrvMsg" );

_LIT( KFileToolWildcard, "file*.prfw" );

_LIT( KFileToolFileBase, "file%d.prfw" );

// ======== LOCAL FUNCTIONS ========

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

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

// ?description_if_needed

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

//

CXIMPTestFileTool::CXIMPTestFileTool( TUint32 aUid ) :

    iUid( aUid )

    {

    iFs.Connect();

    }

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

// ?description_if_needed

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

//

void CXIMPTestFileTool::ConstructL( const TDesC16& aInstanceId )

    {

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iInstance = aInstanceId.AllocL();

    }

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

// ?description_if_needed

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

//

void CXIMPTestFileTool::ConstructL( TInt aInstanceIdAsNum )

    {

    TInt instanceLength = NumLenInChars( aInstanceIdAsNum );

    HBufC* instance = HBufC::NewLC( instanceLength );

    instance->Des().AppendFormat( KInstanceAsNumber, aInstanceIdAsNum );

    ConstructL( *instance );

    CleanupStack::PopAndDestroy( instance );

    }

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

// ?description_if_needed

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

//

EXPORT_C CXIMPTestFileTool* CXIMPTestFileTool::NewL( TUint32 aUid, const TDesC16& aInstanceId )

    {

    CXIMPTestFileTool* self = new( ELeave ) CXIMPTestFileTool( aUid );

    CleanupStack::PushL( self );

    self->ConstructL( aInstanceId );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

EXPORT_C CXIMPTestFileTool* CXIMPTestFileTool::NewL( TUint32 aUid, TInt aInstanceIdAsNum )

    {

    CXIMPTestFileTool* self = new( ELeave ) CXIMPTestFileTool( aUid );

    CleanupStack::PushL( self );

    self->ConstructL( aInstanceIdAsNum );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CXIMPTestFileTool::~CXIMPTestFileTool()

    {

    iFs.Close();

    if ( iTimer )

        {

        iTimer->Deque();

        }

    delete iTimer;

    iObservers.Close();

    delete iInstance;

    }

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

// Remove the entire prfw directory 

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

//

EXPORT_C void CXIMPTestFileTool::CleanAllL()

    {

    RFs fs;

    fs.Connect();

    CleanupClosePushL( fs );

    CFileMan* fileMan = CFileMan::NewL( fs );

    CleanupStack::PushL( fileMan );

    // remove the files and the directory

    fileMan->RmDir( KFileToolMainDirFull );

    CleanupStack::PopAndDestroy( 2 );  // fileman, fs

    }

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

// Prepare everything, after this objects can be externalized and

// internalized

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

//

EXPORT_C void CXIMPTestFileTool::PrepareL()

    {

    // create the directory structure

    HBufC* dirName = GetDirNameAndBackslashLC( KFileToolPluginDirBase );

    iFs.MkDirAll( *dirName );

    CleanupStack::PopAndDestroy( dirName );

    dirName = GetDirNameAndBackslashLC( KFileToolSrvDirBase );

    iFs.MkDirAll( *dirName );

    CleanupStack::PopAndDestroy( dirName );

    }

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

// Write the file to correct directory.

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

//

EXPORT_C void CXIMPTestFileTool::PluginStoreL( const TDesC8& aExternalizedObject )

    {

    HBufC* fileName = GetFileNameLC( 

            KFileToolPluginDirBase,

            iObjIndex );

    RFileWriteStream out;

    CleanupClosePushL( out );

    out.Create( iFs, *fileName, EFileWrite|EFileStream|EFileShareAny );

    // write the file

    TUint32 len = aExternalizedObject.Length();

    out.WriteUint32L( len );

    out.WriteL( aExternalizedObject );

    CleanupStack::PopAndDestroy(); // out

    CleanupStack::PopAndDestroy( fileName ); // fileName

    // next file will have a new index

    iObjIndex++;

    }

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

// Restore the file from given directory and given index

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

//

EXPORT_C CXIMPApiEventBase* CXIMPTestFileTool::PluginRestoreLC(

        TInt aObjIndex )

    {

    HBufC* fileName = GetFileNameLC( 

            KFileToolPluginDirBase, 

            aObjIndex );

    // try to instantiate it

    RFileReadStream in;

    CleanupClosePushL( in );

    in.Open( iFs, *fileName, EFileStream );

    TInt len = in.ReadUint32L();

    HBufC8* buffer = HBufC8::NewLC( len );

    TPtr8 ptr = buffer->Des();

    in.ReadL( ptr );

    // instantiate the object

    TInt32 dummy = 0;

    CXIMPApiEventBase* object = XIMPEventCodec::UnPackL( *buffer, dummy );

    CleanupStack::PopAndDestroy( 2 ); // buffer, in

    // delete the just read object

    iFs.Delete( *fileName );

    CleanupStack::PopAndDestroy( fileName );

    CleanupStack::PushL( object );

    return object;

    }

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

// Write the server message object to correct directory.

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

//

EXPORT_C void CXIMPTestFileTool::SrvMsgStoreL( 

        CXIMPTestFileSrvMsg* aSrvMsg )

    {

    TInt nextObjIndex = NumSrvMsgL();

    HBufC* fileName = GetFileNameLC( 

            KFileToolSrvDirBase,

            nextObjIndex);

    RFileWriteStream out;

    CleanupClosePushL( out );

    TInt retVal = out.Create( iFs, *fileName, EFileWrite|EFileStream|EFileShareAny );

    User::LeaveIfError( retVal );

    aSrvMsg->ExternalizeL( out );

    CleanupStack::PopAndDestroy( 2, fileName ); // out, fileName

    // next file will have a new index

    //iSrvObjIndex++;

    }

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

// Restore the file from given directory and given index

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

//

EXPORT_C CXIMPTestFileSrvMsg* CXIMPTestFileTool::SrvMsgRestoreLC(

        TInt aObjIndex )

    {

    CXIMPTestFileSrvMsg* msg = CXIMPTestFileSrvMsg::NewLC();

    HBufC* fileName = GetFileNameLC( 

            KFileToolSrvDirBase, 

            aObjIndex );

    // try to instantiate it

    RFileReadStream in;

    CleanupClosePushL( in );

    in.Open( iFs, *fileName, EFileStream );

    msg->InternalizeL( in ); 

    CleanupStack::PopAndDestroy(); // in

    // delete the just read object

    iFs.Delete( *fileName );

    CleanupStack::PopAndDestroy( fileName ); // fileName

    return msg;

    }

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

// Common file counting helper

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

//

TInt CXIMPTestFileTool::DoNumObjectsL( const TDesC& aTemplate )

    {

    CDir* dir = GetDirListL( aTemplate );

    TInt count = dir->Count();

    delete dir;

    return count;

    }

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

// Number of objects (files) in a given directory

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

//

EXPORT_C TInt CXIMPTestFileTool::NumObjectsL()

    {

    return DoNumObjectsL( KFileToolPluginDirBase );

    }

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

// Number of server-originated objects (files) in a given directory

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

//

EXPORT_C TInt CXIMPTestFileTool::NumSrvMsgL()

    {

    // returns the number of objects in the directory

    // get file listing and derive the count from that

    return DoNumObjectsL( KFileToolSrvDirBase );

    }

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

// Instace id

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

//

EXPORT_C const TDesC16& CXIMPTestFileTool::InstanceId() const

    {

    return *iInstance;

    }

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

// Length of number in characters (e.g. 501 --> 3)

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

//

TInt CXIMPTestFileTool::NumLenInChars( TInt aNum )

    {

    TInt len = 0;

    TInt tmp = aNum;

    do

        {

        tmp /= 10;  // number is base-10

        len++;

        }

    while ( tmp > 0 );

    return len;

    }

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

// Gets properly expanded directory name with backslash appended

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

//

HBufC* CXIMPTestFileTool::GetDirNameAndBackslashLC( 

        const TDesC& aTemplate )

    {

    TInt uidLength = NumLenInChars( iUid );

    TInt instanceLength = iInstance->Length();

    HBufC* dirName = HBufC::NewLC( 

            KFileToolMainDirFull().Length()

            + KFileToolBackslash().Length()

            + KFileToolDirUid().Length()

            -2  // "%d" gets modified to be the number

            + KFileToolBackslash().Length()

            + uidLength + instanceLength

            + KFileToolBackslash().Length()

            + aTemplate.Length()

            + KFileToolBackslash().Length() // added for later use by GetDirNameAndBackslashLC.

            );

    dirName->Des().Append( KFileToolMainDirFull );

    dirName->Des().Append( KFileToolBackslash );

    dirName->Des().AppendFormat( KFileToolDirUid, iUid );

    dirName->Des().Append( KFileToolBackslash );

    dirName->Des().Append( *iInstance );

    dirName->Des().Append( KFileToolBackslash );

    dirName->Des().Append( aTemplate );

    dirName->Des().Append( KFileToolBackslash );

    iFs.MkDirAll( *dirName );

    return dirName;

    }

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

// Get full path wildcard for files residing in a directory

// with given index

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

//

HBufC* CXIMPTestFileTool::GetWildcardLC( 

        const TDesC& aDirTemplate )

    {

    HBufC* dirName = GetDirNameAndBackslashLC( aDirTemplate );

    HBufC* wildcard = HBufC::NewLC(

            dirName->Length() + KFileToolWildcard().Length() );

    wildcard->Des().Append( *dirName );

    wildcard->Des().Append( KFileToolWildcard );

    CleanupStack::Pop( 2 ); // wildcard, dirName

    delete dirName;

    CleanupStack::PushL( wildcard );

    return wildcard;

    }

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

// Get a list of files in a given directory

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

//

CDir* CXIMPTestFileTool::GetDirListL( const TDesC& aTemplate )

    {

    HBufC* wildcard = GetWildcardLC( aTemplate );

    CDir* dirList = NULL;

    iFs.GetDir( *wildcard, KEntryAttNormal, ESortByName, dirList );

    CleanupStack::PopAndDestroy( wildcard );

    return dirList;

    }

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

// Get fully qualified file name

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

//

HBufC* CXIMPTestFileTool::GetFileNameLC( 

        const TDesC& aDirTemplate,

        TInt aObjIndex )

    {

    // create file name

    HBufC* dirName = GetDirNameAndBackslashLC( aDirTemplate );

    TInt numLen = NumLenInChars( aObjIndex );

    HBufC* fileName = HBufC::NewLC(

            dirName->Length()

            + KFileToolFileBase().Length()

            + numLen

            - 2  // "%d" gets modified to be the number

            );

    fileName->Des().Append( *dirName );

    fileName->Des().AppendFormat( KFileToolFileBase, aObjIndex );

    CleanupStack::Pop( fileName );

    CleanupStack::PopAndDestroy( dirName );

    CleanupStack::PushL( fileName );

    // now we have the filename

    return fileName;

    }

const TInt KSecond = 1000000;

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

// CXIMPTestFileTool::RegisterObserverL

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

//

void CXIMPTestFileTool::RegisterObserverL( MXIMPTestFileObserver* aObserver )

    {    

    iObservers.AppendL( aObserver );

    if( !iTimer->IsActive() )

        {

        TCallBack callback( Process, this );

        iTimer->Start( KSecond, KSecond, callback );

        }        

    }

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

// CXIMPTestFileTool::UnregisterObserver

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

//

void CXIMPTestFileTool::UnregisterObserver( MXIMPTestFileObserver* aObserver )

    {    

    TInt index = iObservers.Find( aObserver );

    if( index != KErrNotFound )

        {

        iObservers.Remove( index );

        }

    if( iObservers.Count() == 0 )

        {

        iTimer->Cancel();

        }

    }

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

// CXIMPTestFileTool::RunL

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

//

TInt CXIMPTestFileTool::Process( TAny* aMyself )

    {

    TRAPD( ignore, ( static_cast< CXIMPTestFileTool* >( aMyself ) )->DoProcessL() );

    return 0; // ignored by CPeriodic

    }

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

// CXIMPTestFileTool::RunL

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

//

void CXIMPTestFileTool::DoProcessL()

    {

    TInt countOfSrvMsg = NumSrvMsgL();

    TInt countOfObservers = iObservers.Count();

    for( TInt a = 0; a < countOfSrvMsg; ++a )

        {

        CXIMPTestFileSrvMsg* newMsg = SrvMsgRestoreLC( a );

        for( TInt b = 0;b < countOfObservers; ++b )

            {

            iObservers[ b ]->HandleL( newMsg->SrvMsgId(), newMsg->PayloadL() );

            }

        CleanupStack::PopAndDestroy( newMsg );

        }

    }

// End of file