/*
* Copyright (c) 2002 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:   ?Description*
*/


#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroyPushL
#include <e32property.h>

#include "VCXTestCommon.h"
#include "CIptvTestTimer.h"
#include "VCXConnUtilTestCommon.h"
#include "VCXConnUtilTestExeTester.h"
#include "VCXConnUtilTestSubscriber.h"
#include "VCXConnUtilTestPSObserver.h"
#include "VCXConnUtilTester.h"

#include "VCXTestLog.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVCXConnUtilTestExeTester* CVCXConnUtilTestExeTester::NewL( TUint aProcessId )
    {
    VCXLOGLO1(">>>CVCXConnUtilTestExeTester::NewL");
    CVCXConnUtilTestExeTester* self = new (ELeave) CVCXConnUtilTestExeTester();
    CleanupStack::PushL(self);
    self->ConstructL( aProcessId );
    CleanupStack::Pop( self );
    VCXLOGLO1("<<<CVCXConnUtilTestExeTester::NewL");
    return self;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::~CVCXConnUtilTestExeTester
// destructor
// -----------------------------------------------------------------------------
//
CVCXConnUtilTestExeTester::~CVCXConnUtilTestExeTester()
    {
    VCXLOGLO1(">>>CVCXConnUtilTestExeTester::~CVCXConnUtilTestExeTester");

    delete iGlobalShutdownSubcriber;
    iGlobalShutdownSubcriber = NULL;

    delete iCmdSubcriber;
    iCmdSubcriber = NULL;

    delete iTester;
    iTester = NULL;

    // Remove the P&S keys for this process.
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmd + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdIntParam2 + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdDescParam1 + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase);
    RProperty::Delete( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase);

    VCXLOGLO1("<<<CVCXConnUtilTestExeTester::~CVCXConnUtilTestExeTester");
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::~CVCXConnUtilTestExeTester
// destructor
// -----------------------------------------------------------------------------
//
CVCXConnUtilTestExeTester::CVCXConnUtilTestExeTester()
    {
    VCXLOGLO1(">>>CVCXConnUtilTestExeTester::CVCXConnUtilTestExeTester");

    VCXLOGLO1("<<<CVCXConnUtilTestExeTester::CVCXConnUtilTestExeTester");
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::ConstructL
//
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTestExeTester::ConstructL( TUint aProcessId )
    {
    VCXLOGLO1(">>>CVCXConnUtilTestExeTester::ConstructL");

    iTester = CVCXConnUtilTester::NewL();

    // Define and listen global shutdown key.
    
    TInt err( KErrNone );
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalShutdownKey, RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExeGlobalShutdownKey: %d, err: %d", 
            KVCXConnUtilTestExeGlobalShutdownKey, err);

    iGlobalShutdownSubcriber = CVCXConnUtilTestSubscriber::NewL( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExeGlobalShutdownKey, RProperty::EInt, this );
    iGlobalShutdownSubcriber->Start();
    VCXLOGLO2("CVCXConnUtilTestExeTester:: Listening P&S key KVCXConnUtilTestExeGlobalShutdownKey: %d",
            KVCXConnUtilTestExeGlobalShutdownKey);
    
    // Get PS key base.
    
    TInt testerCount( 0 );
    
    User::LeaveIfError( CVCXTestCommon::GetPSProperty( 
            KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalTesterCount, testerCount ) );

    testerCount++;
    
    iPSKeyBase = testerCount * 1000 + aProcessId;

    VCXLOGLO2("CVCXConnUtilTestExeTester:: iPSKeyBase: %d", iPSKeyBase);
    
    // Define private P&S keys.
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmd + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyCmd: %d, err: %d", 
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyCmdIntParam1: %d, err: %d", 
            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdIntParam2 + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyCmdIntParam2: %d, err: %d", 
            KVCXConnUtilTestExePsKeyCmdIntParam2 + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyCmdDescParam1 + iPSKeyBase,
            RProperty::EText );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyCmdDescParam1: %d, err: %d", 
            KVCXConnUtilTestExePsKeyCmdDescParam1 + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyResponseAck: %d, err: %d", 
            KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyResponseCmd: %d, err: %d", 
            KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyResponseParam: %d, err: %d", 
            KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase, err);
    
    err = RProperty::Define( KVCXConnUtilTestPScategory, KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase,
            RProperty::EInt );
    VCXLOGLO3("CVCXConnUtilTestExeTester:: Define KVCXConnUtilTestExePsKeyResponseError: %d, err: %d", 
            KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase, err);
    
    // Subscribe P&S cmd key.

    iCmdSubcriber = CVCXConnUtilTestSubscriber::NewL( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, RProperty::EInt, this );
    iCmdSubcriber->Start();
    VCXLOGLO2("CVCXConnUtilTestExeTester:: Listening P&S key KVCXConnUtilTestExePsKeyCmd: %d", 
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase);

    iRunning = ETrue;

    // And update the tester count to P&S.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( 
            KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalTesterCount, testerCount ) );
    
    VCXLOGLO1("<<<CVCXConnUtilTestExeTester::ConstructL");
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::ValueChangedL
//
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTestExeTester::ValueChangedL( const TUid& aUid, const TUint32& aKey, const TInt&  aValue )
    {
    // Right now this is only category we are subscribing for.
    if( aUid != KVCXConnUtilTestPScategory )
        {
        return;
        }

    if( aKey == KVCXConnUtilTestExeGlobalShutdownKey )
        {
        if( aValue == 1 )
            {
            iRunning = EFalse;
            VCXLOGLO2("CVCXConnUtilTestExeTester::ValueChangedL: cmd GLOBAL SHUTDOWN (%S) ----->", &iName);
            }
        return;
        }

    VCXLOGLO2(">>>CVCXConnUtilTestExeTester::ValueChangedL TInt (%S)", &iName);

    // Store possible parameters.
    TInt intParam1(0);
    TInt intParam2(0);
    TBuf<256> descParam1;

    CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory, 
            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, intParam1 );
    CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory, 
            KVCXConnUtilTestExePsKeyCmdIntParam2 + iPSKeyBase, intParam2 );
    CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory, 
            KVCXConnUtilTestExePsKeyCmdDescParam1 + iPSKeyBase, descParam1 );

    // Set response that cmd has been gotten.

    VCXLOGLO2("CVCXConnUtilTestExeTester:: Setting KVCXConnUtilTestExePsKeyResponseAck (%S) ----->", &iName);
    CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory, 
            KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase, iAckCount++ );

    // Handle commands.
    if( aKey == KVCXConnUtilTestExePsKeyCmd + iPSKeyBase )
        {
        switch( aValue )
            {
            case EVcxConnUtilCommandShutdown:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandShutdown (%S) ----->", &iName);
                iRunning = EFalse;
                }
                break;

            case EVcxConnUtilCommandSetName:
                {
                iName.Copy( descParam1 );
                iTester->iName.Copy( descParam1 );
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandSetName (%S) ----->", &iName);
                }
                break;

            case EVcxConnUtilCommandGetIap:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandGetIap (%S) ----->", &iName);

                TUint32 iapId(0);
                TBool silent = static_cast<TBool>( intParam1);
                TBool isTimed = static_cast<TBool>( intParam2 );

                TInt err = iTester->GetIap( iapId, silent, isTimed );

                if( err != KErrNone || iapId == 0 )
                    {
                    VCXLOGLO4("CVCXConnUtilTestExeTester:: GetIap error: %d, iap: %d (%S)", err, iapId, &iName);
                    }

                VCXLOGLO2("CVCXConnUtilTestExeTester:: Setting response for EVcxConnUtilCommandGetIap (%S) ----->", 
                        &iName);
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase, iapId );
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase, err );
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase, EVcxConnUtilCommandGetIap );

                }
                break;
                
                
            case EVcxConnUtilCommandGetWapIdForIap:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandGetWapIdForIap (%S) ----->", &iName);

                TInt err( KErrNone );
                
                TUint32 wapId( 0 );
                TRAP( err, iTester->WapIdFromIapIdL( intParam1 ) );

                VCXLOGLO4("CVCXConnUtilTestExeTester:: GetWapIdFromIapIdL returned wapId: %d, err: %d (%S)", wapId, err, &iName);

                VCXLOGLO2("CVCXConnUtilTestExeTester:: Setting response for EVcxConnUtilCommandGetWapIdForIap (%S) ----->", 
                        &iName);
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase, wapId );
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase, err );
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase, EVcxConnUtilCommandGetWapIdForIap );

                }
                break;

            case EVcxConnUtilCommandDisconnect:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandDisconnect (%S) ----->", &iName);

                TInt err = iTester->Disconnect();

                if( err != KErrNone )
                    {
                    VCXLOGLO3("CVCXConnUtilTestExeTester:: disconnect error: %d (%S)", err, &iName);
                    }

                VCXLOGLO2("CVCXConnUtilTestExeTester:: Setting response for EVcxConnUtilCommandDisconnect (%S) ----->", 
                        &iName);
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase, err );
                CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
                        KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase, EVcxConnUtilCommandDisconnect );
                }
                break;

            case EVcxConnUtilCommandSetRoamingAllowed:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandSetRoamingAllowed (%S) ----->", 
                        &iName);
                iTester->iIsRoamingAllowed = intParam1;
                }
                break;

            case EVcxConnUtilCommandSetRoamingLeaveAtRoamingRequest:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandSetRoamingLeaveAtRoamingRequest (%S) ----->", &iName);
                iTester->iLeaveAtRoamingRequest = intParam1;
                }
                break;

            case EVcxConnUtilCommandSetDelayBeforeRoamingRequest:
                {
                VCXLOGLO2("CVCXConnUtilTestExeTester:: cmd EVcxConnUtilCommandSetDelayBeforeRoamingRequest (%S) ----->", &iName);
                iTester->iDelaySecondsAtRoamingRequest = intParam1;
                }
                break;

            default:
                {
                VCXLOGLO3("CVCXConnUtilTestExeTester:: UNKNOWN cmd %d! (%S) ----->", aValue, &iName);
                }
                break;
            }
        }

    VCXLOGLO2("<<<CVCXConnUtilTestExeTester::ValueChangedL TInt (%S)", &iName);
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTestExeTester::ValueChangedL
//
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTestExeTester::ValueChangedL( const TUid& aUid, const TUint32& /* aKey */, const TDesC& /* aValue */ )
    {
    VCXLOGLO1(">>>CVCXConnUtilTestExeTester::ValueChangedL TDesC");

    if( aUid == KVCXConnUtilTestPScategory )
        {

        }

    VCXLOGLO1("<<<CVCXConnUtilTestExeTester::ValueChangedL TDesC");
    }

//  End of File