/*

* 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 the License "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:   Set and cancel async calls and write logs

*

*/

// INCLUDE FILES

#include <stifitemparser.h>

#include "notify.h"

#include "notifyhandler.h"

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

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

// CSimAtkNotify::CSimAtkNotify

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

// might leave.

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

//

CSimAtkNotify::CSimAtkNotify

        (

        CTestModuleIf& aTestModuleIf

        ) : CScriptBase( aTestModuleIf )

    {

    iNotifyHandler = NULL;

    iCore = NULL;

    }

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

// CSimAtkNotify::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSimAtkNotify::ConstructL()

    {

    iLog = CStifLogger::NewL( KCoreLogPath, KCoreLogFile,

        CStifLogger::ETxt, CStifLogger::EFile, ETrue );

    iNotifyHandler = CSimAtkNotifyHandler::NewL( this, iLog );

    }

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

// CSimAtkNotify::NewL

// Two-phased constructor.

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

//

CSimAtkNotify* CSimAtkNotify::NewL

        (

        CTestModuleIf& aTestModuleIf

        )

    {

    CSimAtkNotify* self = new (ELeave) CSimAtkNotify( aTestModuleIf );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;    

    }

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

// CSimAtkNotify::~CSimAtkNotify

// Destructor

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

// 

CSimAtkNotify::~CSimAtkNotify()

    { 

    delete iNotifyHandler;

    iNotifyHandler = NULL;   

    delete iLog;

    iLog = NULL;

    iCore = NULL;         

    }

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

// CSimAtkNotify::CSimAtkCore

// Return pointer to core class

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

//   

CSimAtkCore* CSimAtkNotify::SimAtkCore()

	{

	return iCore;

	}

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

// CSimAtkNotify::UseObjectAddress

// Notifies and cancels notifys according to script

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

//   

TInt CSimAtkNotify::UseObjectAddress

        (

        CStifItemParser& aItem

        )

    {

    TPtrC objectName;

    TInt ret ( KErrNone );

    // Find tag

    ret = aItem.GetString( _L( "UseObjectAddress" ), objectName );

    CScriptBase* script = GetTestObject( objectName );

    // This must be done every time GetTestObject is just called

    if ( NULL == script )

        {

        iLog->Log( _L( "CSimAtkNotify::UseObjectAddresL \

            - Script == NULL" ) );

        ret = KErrGeneral;

        }

    else

        {

        iLog->Log( _L ( "CSimAtkNotify::UseObjectAddressL \

            - Start to cast objects " ) );    

        iCore = reinterpret_cast <CSimAtkCore*>( script );

    	// Identify the type of notify

    	TPtrC notifyPtr;

    	ret = aItem.GetNextString( notifyPtr );

    	if ( KErrNone == ret )

    	    {

            // Potential notify string found. Identify the notify or

            // cancellation and map it to an ipc.

        	TSatIpc notifyIpc;

        	TBool isNotify = EFalse;

        	notifyIpc = iCore->MapStringToIpc( notifyPtr, isNotify );

        	if ( isNotify && ( notifyIpc != KErrNotFound ) )

            	{

            	iNotifyHandler->SetNotify( notifyIpc );

                ret = iCore->Notify( iNotifyHandler->Status(), notifyIpc );

                if ( KErrNone == ret )

                    {

                	iLog->Log( _L ( "CSimAtkNotify::UseObjectAddressL \

                	    Notify %S " ), &notifyPtr );

                  	iNotifyHandler->Activate();    			

                    }

                else

                    {

                	iLog->Log( _L ( "CSimAtkNotify::UseObjectAddressL \

                	    Notifying of %S failed! " ), &notifyPtr );

                  	iNotifyHandler->Cancel();    			

                    }                    

            	}

        	else if ( EFalse == isNotify )// This is cancellation of notify

            	{

            	iNotifyHandler->Cancel();    			

            	iLog->Log( _L( "CSimAtkNotify::UseObjectAddressL \

            	    - object Canceled " ) );

            	}

            else

                {

            	iLog->Log( _L( "CSimAtkNotify::UseObjectAddressL \

            	    - Unsupported notify request received! Aborting..." ) );

            	iNotifyHandler->Cancel();

                ret = KErrNotFound;

                }

        	iLog->Log( _L( "CSimAtkNotify::UseObjectAddressL \

        	    Method done " ) );

            }

	    }

    return ret;

    }

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

// CSimAtkNotify::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//   

TInt CSimAtkNotify::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    TInt count = 0;

    const TStifFunctionInfo* functions = RunMethodCases( count );

    return CScriptBase::RunInternalL( functions, count, aItem );

    }

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

// CSimAtkNotify::RunInternalL

// Run specified method from derived class or core class.

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

// 

TInt CSimAtkNotify::RunInternalL

        ( 

        TStifFunctionInfo const aFunctions[], // Function table

        TInt aCount, // Size of function table

        CStifItemParser& aItem // reference to parser

        )

    {

    iLog->Log( _L( "CSimAtkNotify::RunInternalL " ) );

    TInt count = 0;

    const TStifFunctionInfo* functions = RunMethodCases( count );

    TInt total = count + aCount;

    TUint8* tmp = new( total * sizeof( TStifFunctionInfo ) ) TUint8;

    User::LeaveIfNull( tmp );

    TStifFunctionInfo* allFuncs = ( TStifFunctionInfo* ) tmp;

    Mem::Copy( &allFuncs[0], aFunctions,

        aCount * sizeof( TStifFunctionInfo ) );

    Mem::Copy( &allFuncs[aCount], functions,

        count * sizeof( TStifFunctionInfo ) );

    TInt ret = CScriptBase::RunInternalL( allFuncs, total, aItem );

    delete tmp;

    return ret;

    }

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

// CSimAtkNotify::RunMethodCases

// Return function table.

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

//   

const TStifFunctionInfo* CSimAtkNotify::RunMethodCases( TInt& aCount ) 

    { 

	static TStifFunctionInfo const KFunctions[] =

   	 	{

   	 	// Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

    	ENTRY( "UseObjectAddress", CSimAtkNotify::UseObjectAddress ),

    	};

    aCount = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

    return KFunctions;

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

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

// LibEntryL is a polymorphic Dll entry point.

// Returns: CScriptBase: New CScriptBase derived object

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

//

EXPORT_C CScriptBase* LibEntryL

        (

        CTestModuleIf& aTestModuleIf // Backpointer to STIF Test Framework

        )

    {

    return ( CScriptBase* ) CSimAtkNotify::NewL( aTestModuleIf );

    }    

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

// E32Dll is a DLL entry point function.

// Returns: KErrNone

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

//

#ifndef EKA2 // Hide Dll entry point to EKA2

GLDEF_C TInt E32Dll

        (

        TDllReason /*aReason*/ // Reason code

        ) 

    {

    return(KErrNone);

    }

#endif // EKA2

//  End of File