/*
* Copyright (c) 2008 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: 
*
*/


// INCLUDE FILES

#include "TestUtilConnection.h"

#include "VCXTestLog.h"
#include "MTestUtilConnectionObserver.h"
#include <es_enum.h>

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

// ---------------------------------------------------------------------------
// CTestUtilConnection::NewL()
//
// Constructs CTestUtilConnection object
// ---------------------------------------------------------------------------
//
EXPORT_C CTestUtilConnection* CTestUtilConnection::NewL(MTestUtilConnectionObserver* aObserver)
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::NewL");
    CTestUtilConnection* self = NewLC(aObserver);
    CleanupStack::Pop(self);
    VCXLOGLO1("<<<CIptvTestUtilConnection::NewL");
    return self;
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::NewLC()
//
// Constructs CTestUtilConnection object
// ---------------------------------------------------------------------------
//
EXPORT_C CTestUtilConnection* CTestUtilConnection::NewLC(MTestUtilConnectionObserver* aObserver)
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::NewLC");
    CTestUtilConnection* self = new (ELeave) CTestUtilConnection(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    VCXLOGLO1("<<<CIptvTestUtilConnection::NewLC");
    return self;
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::CTestUtilConnection()
//
// Constructor
// ---------------------------------------------------------------------------
//
CTestUtilConnection::CTestUtilConnection(MTestUtilConnectionObserver* aObserver)
: CActive(CActive::EPriorityHigh), iConnectionState(EIdle), iObserver(aObserver)
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::CIptvTestUtilConnection");
    SetConnectionPreferences(ECommDbBearerUnknown, 0);
    VCXLOGLO1("<<<CIptvTestUtilConnection::CIptvTestUtilConnection");
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::~CTestUtilConnection()
//
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CTestUtilConnection::~CTestUtilConnection()
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::~CIptvTestUtilConnection");
   	Cancel();

    iConnect.Close();
    iSocketServ.Close();

//	iTimer.Cancel();
//	iTimer.Close();

   	if( IsAdded() )
        {
        Deque(); // calls also Cancel()
        }

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

// ---------------------------------------------------------------------------
// CTestUtilConnection::ConstructL()
//
// Second phase constructor
// ---------------------------------------------------------------------------
//
void CTestUtilConnection::ConstructL()
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::ConstructL");

   	iSocketServ.Connect();
    iConnect.Open(iSocketServ);

//    User::LeaveIfError(iTimer.CreateLocal());

	CActiveScheduler::Add(this);

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

// ---------------------------------------------------------------------------
// CTestUtilConnection::ConnectL()
//
// Start connecting to IAP.
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestUtilConnection::ConnectL()
	{
	VCXLOGLO1(">>>CIptvTestUtilConnection::ConnectL");

	if(iConnectionState == CTestUtilConnection::EConnected)
		{
		VCXLOGLO1(">>>CIptvTestUtilConnection:: Already connected");
		return;
		}

	if (!IsActive())
		{
        iConnect.Start(iPref, iStatus);
        iConnectionState = CTestUtilConnection::EConnecting;

	//if the line below panics it's either because you made a request but you haven't
	//SetActive the object (pR->iStatus.iFlags&TRequestStatus::EActive==0) or you didn't set the iStatus
	//to KRequestPending (pR->iStatus.iFlags&TRequestStatus::ERequestPending==0)
//		iTimerStatus = KRequestPending;
//	    iTimer.After(iTimerStatus, KTimeout);

		SetActive();
		VCXLOGLO1(">>>CIptvTestUtilConnection:: Connecting");
        }
	else
		{
		//globalNote->ShowNoteL(EAknGlobalInformationNote, KTextNotReady);
		}
	VCXLOGLO1("<<<CIptvTestUtilConnection::ConnectL");
	}


// ---------------------------------------------------------------------------
// CTestUtilConnection::AttachL()
//
// Attach to open IAP.
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestUtilConnection::AttachL()
	{
	VCXLOGLO1(">>>CIptvTestUtilConnection::AttachL");

	if(iConnectionState == CTestUtilConnection::EConnected)
		{
		VCXLOGLO1(">>>CIptvTestUtilConnection:: Already connected");
		VCXLOGLO1("<<<CIptvTestUtilConnection::AttachL");
		User::Leave(KErrAlreadyExists);
		}

	if (!IsActive())
		{
        TUint activeConnections = 0;
        User::LeaveIfError(iConnect.EnumerateConnections(activeConnections));

        TConnectionInfo info;
        TPckg<TConnectionInfo> infoPckg(info);

        TInt found = EFalse;
        for(TInt i=1;i<=activeConnections;i++)
        	{

			User::LeaveIfError(iConnect.GetConnectionInfo(i, infoPckg));

			VCXLOGLO3("CIptvTestUtilConnection:: %d vs %d.", iPref.IapId(), info.iIapId);

			if(info.iIapId == iPref.IapId())
				{
				found = ETrue;
				break;
				}

        	}
        if(!found)
        	{
			VCXLOGLO1(">>>CIptvTestUtilConnection:: No connection found to that AP.");
			VCXLOGLO1("<<<CIptvTestUtilConnection::AttachL");
        	User::Leave(KErrNotFound);
        	}

        User::LeaveIfError(iConnect.Attach(infoPckg, RConnection::EAttachTypeNormal));
        iConnectionState = CTestUtilConnection::EConnected;
        }

	VCXLOGLO1("<<<CIptvTestUtilConnection::AttachL");
	return;
	}

// ---------------------------------------------------------------------------
// CTestUtilConnection::RunL()
//
// Handle request completion events
// ---------------------------------------------------------------------------
//
void CTestUtilConnection::RunL()
	{
 	VCXLOGLO1(">>>CIptvTestUtilConnection::RunL");

	/*if(iTimerStatus.Int() == KErrNone)
		{
		VCXLOGLO1("CTestUtilConnection:: Connection timeout.");
		iObserver->ConnectionTimeout();
		iTimer.Cancel();
		}
 */
    TInt statusCode = iStatus.Int();

    switch (statusCode)
	    {
	    case KErrNone: // Connection created succesfully
	        {
	        //PrintNoteL(KTextConnectionCreated);
	        VCXLOGLO1("CTestUtilConnection:: Connection created.");
	        iConnectionState = CTestUtilConnection::EConnected;
//	        iTimer.Cancel();
	        iObserver->ConnectionCreated();
	        break;
	        }

	    case KErrNotFound: // Connection failed
	        {
	        //PrintNoteL(KTextGeneralError);
	        VCXLOGLO1("CTestUtilConnection:: Connection failed.");
	        iConnectionState = CTestUtilConnection::EFailed;
	        //iTimer.Cancel();
	        iObserver->ConnectionFailed();
	        break;
	        }

	    case KErrCancel: // Connection attempt cancelled
	        {
	        //PrintNoteL(KTextConnectionCancelled);
	        VCXLOGLO1("CTestUtilConnection:: Connection attemption canceled.");
	        iConnectionState = CTestUtilConnection::EFailed;
//	        iTimer.Cancel();
	        iObserver->ConnectionFailed();
	        break;
	        }

	    case KErrAlreadyExists: // Connection already exists
	        {
	        //PrintNoteL(KTextConnectionExists);
	        VCXLOGLO1("CTestUtilConnection:: Connection already exists.");
	        iConnectionState = CTestUtilConnection::EFailed;
//	        iTimer.Cancel();
	        iObserver->ConnectionAlreadyExists();
	        break;
	        }

	    default:
	        {
	        //TBuf<KErrorResolverMaxTextLength> errorText;
	        // Use text resolver to resolve error text
	        //errorText = iTextResolver->ResolveError(statusCode);
	        //PrintErrorL(errorText, statusCode);
	        VCXLOGLO2("CTestUtilConnection:: Unknown error: %d", statusCode);
	        iConnectionState = CTestUtilConnection::EFailed;
//	        iTimer.Cancel();
	        iObserver->ConnectionFailed();
	        break;
	        }
        }

    VCXLOGLO1("<<<CIptvTestUtilConnection::RunL");
	}

// ---------------------------------------------------------------------------
// CTestUtilConnection::DoCancel()
//
// Cancels ongoing requests
// ---------------------------------------------------------------------------
//
void CTestUtilConnection::DoCancel()
	{
	VCXLOGLO1(">>>CIptvTestUtilConnection::DoCancel");
	VCXLOGLO1("<<<CIptvTestUtilConnection::DoCancel");
    // Nothing to do here
	}


// ---------------------------------------------------------------------------
// CTestUtilConnection::TerminateConnectionL()
//
// This function should not be used in normal situation, since it terminates
// the active connection, even if there are other application using
// the connection. Calling the RConnection::Close() closes the connection.
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestUtilConnection::TerminateConnectionL()
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::TermínateConnectionL");

/*
    if (iProgressNotifier->GetState() == EIAPConnectStateConnected)
        {
        // Show confirmation dialog first
        if (ShowQueryDialogL())
            {
            // RConnection::Stop() terminates connection by stopping whole
            // network interface even if there are other clients using
            // the connection. It is not recommended to use it unless it is
            // really meaningful.
            User::LeaveIfError(iConnect.Stop());

            }
        }
    else
        {
        PrintNoteL(KTextNotConnected);
        }
        */
    User::LeaveIfError(iConnect.Stop());
    VCXLOGLO1("<<<CIptvTestUtilConnection::TermínateConnectionL");
    }

CTestUtilConnection::TConnectionState CTestUtilConnection::GetState()
    {
    return iConnectionState;
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::SetConnectionPreferences(TUint aBearer,
//                                                 TBool aDialog,
//                                                 TUint32 aIapId)
//
// This function sets connection preferences.
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestUtilConnection::SetConnectionPreferences(
    TUint aBearer,
    TUint32 aIapId)
    {
    VCXLOGLO1(">>>CIptvTestUtilConnection::SetConnectionPreferences");
    iPref.SetDirection(ECommDbConnectionDirectionOutgoing);
	iPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
    iPref.SetIapId(aIapId);
    iPref.SetBearerSet(aBearer);
    iPref.SetDirection(ECommDbConnectionDirectionOutgoing);
	VCXLOGLO1("<<<CIptvTestUtilConnection::SetConnectionPreferences");
    }

// End of file