/*
* 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 <S32STRM.H>
#include <S32MEM.H>

#include "VCXTestLog.h"

#include "VCXConnUtilTester.h"
#include "vcxconnectionutility.h"
#include "CIptvTestTimer.h"
#include "CIptvTestActiveWait.h"

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::NewL
// -----------------------------------------------------------------------------
//
CVCXConnUtilTester* CVCXConnUtilTester::NewL()
    {
    VCXLOGLO1(">>>CVCXConnUtilTester::NewL");
    CVCXConnUtilTester* self = new (ELeave) CVCXConnUtilTester();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    VCXLOGLO1("<<<CVCXConnUtilTester::NewL");
    return self;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::CVCXConnUtilTester
// -----------------------------------------------------------------------------
//
CVCXConnUtilTester::CVCXConnUtilTester()
    {

    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::ConstructL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTester::ConstructL()
    {
    VCXLOGLO1(">>>CVCXConnUtilTester::ConstructL");

    iIsRoamingAllowed = ETrue;
    iLeaveAtRoamingRequest = EFalse;
    iDelaySecondsAtRoamingRequest = 0;

    iConnUtil = CVcxConnectionUtility::InstanceL();
    iConnUtil->RegisterObserverL( this );

    iTimer = CIptvTestTimer::NewL( *this, 0 );

    iWait = CIptvTestActiveWait::NewL();

    VCXLOGLO1("<<<CVCXConnUtilTester::ConstructL");
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::~CVCXConnUtilTester
// -----------------------------------------------------------------------------
//
CVCXConnUtilTester::~CVCXConnUtilTester()
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::~CVCXConnUtilTester (%S)", &iName);

    if( iConnUtil )
        {
        iConnUtil->RemoveObserver( this );
        TRAP_IGNORE( iConnUtil->DisconnectL() );
        iConnUtil->DecreaseReferenceCount();
        }
    iConnUtil = NULL;

    if( iTimer )
        {
        iTimer->CancelTimer();
        delete iTimer;
        iTimer = NULL;
        }

    delete iWait;
    iWait = NULL;

    VCXLOGLO2("<<<CVCXConnUtilTester::~CVCXConnUtilTester (%S)", &iName);
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::GetIap
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTester::GetIap( TUint32& aIapId, TBool aSilent, TBool aIsTimed )
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::GetIap (%S)", &iName);
    VCXLOGLO2("CVCXConnUtilTester:: isTimed: %d", aIsTimed);

    if( aIsTimed )
        {
        // Time GetIap request when next minute starts
        TInt seconds( 0 );
        TTime now;
        now.HomeTime();

        TDateTime time = now.DateTime();

        if( time.Second() >= 55 )
            {
            seconds += 10; // Wait extra 10 seconds to make sure any other test module is ready.
            }

        seconds += 60 - time.Second(); // Wait to end of minute

        VCXLOGLO3("CVCXConnUtilTester:: waiting %d seconds (%S)", seconds, &iName);

        TUint32 microSeconds( 0 );
        microSeconds = seconds * 1000000;

        microSeconds += 1 - time.MicroSecond(); // And any extra microseconds

        iTimer->After( microSeconds );
        iWait->Start();
        }

    VCXLOGLO2("CVCXConnUtilTester:: making GetIap call (%S) ----->", &iName);
    TInt err = iConnUtil->GetIap( aIapId, aSilent );
    VCXLOGLO2("CVCXConnUtilTester:: GetIap returns: %d", err);
    VCXLOGLO2("<<<CVCXConnUtilTester::GetIap (%S)", &iName);
    return err;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::WapIdFromIapIdL
// -----------------------------------------------------------------------------
//
TUint32 CVCXConnUtilTester::WapIdFromIapIdL( const TInt32& aIapId )
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::WapIdFromIapIdL (%S) ----->", &iName);
    TUint32 aWapId = iConnUtil->WapIdFromIapIdL( aIapId );
    VCXLOGLO2("CVCXConnUtilTester:: WapIdFromIapIdL returns %d", aWapId);
    VCXLOGLO2("<<<CVCXConnUtilTester::WapIdFromIapIdL (%S)", &iName);
    return aWapId;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::Disconnect
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTester::Disconnect()
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::Disconnect (%S) ----->", &iName);
    TRAPD( err, iConnUtil->DisconnectL() );
    VCXLOGLO2("CVCXConnUtilTester:: Disconnect returns %d", err);
    VCXLOGLO2("<<<CVCXConnUtilTester::Disconnect (%S)", &iName);
    return err;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::RequestIsRoamingAllowedL
// -----------------------------------------------------------------------------
//
TBool CVCXConnUtilTester::RequestIsRoamingAllowedL()
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::RequestIsRoamingAllowedL (%S) ----->", &iName);

    if( iLeaveAtRoamingRequest )
        {
        VCXLOGLO1("CVCXConnUtilTester:: iLeaveAtRoamingRequest set. LEAVING!");
        User::Leave( KErrTotalLossOfPrecision  );
        }

    if( iDelaySecondsAtRoamingRequest > 0 )
        {
        VCXLOGLO2("CVCXConnUtilTester:: delay: %d", iDelaySecondsAtRoamingRequest );
        iTimer->After( iDelaySecondsAtRoamingRequest * 1000000 );
        iWait->Start();
        }

    VCXLOGLO2("CVCXConnUtilTest:: iIsRoamingAllowed = %d", iIsRoamingAllowed);

    VCXLOGLO2("<<<CVCXConnUtilTester::RequestIsRoamingAllowedL (%S)", &iName);
    return iIsRoamingAllowed;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTester::IapChangedL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTester::IapChangedL()
    {
    VCXLOGLO2(">>>CVCXConnUtilTester::IapChangedL (%S)", &iName);
    VCXLOGLO2("<<<CVCXConnUtilTester::IapChangedL (%S)", &iName);
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::TimerComplete
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTester::TimerComplete( TInt /* aTimerId */, TInt aError )
    {
    VCXLOGLO3(">>>CVCXConnUtilTester::TimerComplete, err: %d (%S)", aError, &iName);
    iWait->Stop();
    VCXLOGLO2("<<<CVCXConnUtilTester::TimerComplete (%S)", &iName);
    }


// EOF