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


// INCLUDE FILES

#include "DrmUdtConn.h"
#include "DrmUdtObserver.h"

#include <CommDbConnPref.h>
#include <commdb.h>
#include <cdblen.h>
#include <es_enum.h>

// #include <ApSelect.h> // for checking APs

#ifdef _DEBUG
#define LOGGING
#endif

#define LOGGING

#ifdef LOGGING
_LIT(KLogDir, "DRM");
_LIT(KLogName, "UDT.log");
#include "flogger.h"
#define LOG(string) \
	RFileLogger::Write(KLogDir, KLogName, \
		EFileLoggingModeAppend, string);
#define LOGHEX(buffer) \
	RFileLogger::HexDump(KLogDir, KLogName, \
		EFileLoggingModeAppend, _S(""), _S(""), \
		buffer.Ptr(), buffer.Length());
#else
#define LOG
#define LOGHEX        
#endif

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

// ---------------------------------------------------------
// CDrmUdtConn::NewL()
// ---------------------------------------------------------
//
CDrmUdtConn* CDrmUdtConn::NewL()
    {
    LOG( _L("CDrmUdtConn::NewL") );
    CDrmUdtConn* conn = new (ELeave) CDrmUdtConn();
    CleanupStack::PushL( conn );
    conn->ConstructL();
    CleanupStack::Pop( conn );
    return conn;
    }

// ---------------------------------------------------------
// CDrmUdtConn::~CDrmUdtConn()
// ---------------------------------------------------------
//
CDrmUdtConn::~CDrmUdtConn()
    {
    LOG( _L("CDrmUdtConn::~CDrmUdtConn") );
    Cancel();
    iConnection.Close();
    iSocketServ.Close();
    }

// ---------------------------------------------------------
// CDrmUdtConn::ConnectL()
// ---------------------------------------------------------
//
void CDrmUdtConn::ConnectL( TUint32 aIap,
                            MDrmUdtObserver* aObserver,
                            TRequestStatus* aStatus )
    { 
    LOG( _L("CDrmUdtConn::ConnectL") );
    
    iObserver = aObserver;
    
    if ( iState == EInit )
        {
        // Not connected. Attach to existing connection, or create new one if
        // allowed.
        iStatus = KErrGeneral;

        // Make this part atomic by pushing closes on the stack.
        User::LeaveIfError( iSocketServ.Connect() );
        CleanupClosePushL<RSocketServ>( iSocketServ );
        User::LeaveIfError( iConnection.Open( iSocketServ ) );
        CleanupClosePushL<RConnection>( iConnection );
                
        TConnectionInfoBuf connInfo;
        TUint count;
        User::LeaveIfError( iConnection.EnumerateConnections( count ) );
        TUint i;
        if ( count )
            {
            // Select from existing connections. Try to make AP match.
            for ( i = count; i; i-- )
                {
                // Note: GetConnectionInfo expects 1-based index.
                User::LeaveIfError( iConnection.GetConnectionInfo( i, connInfo ) );
                if ( aIap == 0 || connInfo().iIapId == aIap )
                    {
                    // "Accept any" or AP match. Attach to this one.
                    break;
                    }
                }
            if ( !i )
                {
                // No AP match, select AP with largest index.
                User::LeaveIfError
                    ( iConnection.GetConnectionInfo( count, connInfo ) );
                }
            User::LeaveIfError
                ( iConnection.Attach( connInfo, RConnection::EAttachTypeNormal ) );
            iState = EConnected;
            iStatus = KErrNone;
            }
        else
            {
            // No existing connections, create new one.
#ifdef __WINS__
            // WINS connection creation does not work if preferences are given.
            // Defaults are to be used always.
            iConnection.Start( iStatus );
#else
            // Note: the TCommDbConnPref must NOT be stack variable.
            // It must persist until completion of RConnection::Start().
            iConnPref.SetDirection( ECommDbConnectionDirectionOutgoing );
            iConnPref.SetDialogPreference( ECommDbDialogPrefPrompt );
            iConnPref.SetBearerSet( ECommDbBearerCSD | ECommDbBearerWcdma );
            // New connection is always created with user-selected AP;
            // so 0 is used instead of aIap.
            iConnPref.SetIapId( 0 );
            iConnection.Start( iConnPref, iStatus );
#endif
            if ( iObserver )
                {
                iObserver->ConnectionStartedL();
                }

            iState = EConnecting;
            SetActive();    // The only path with a real async request.
            }
        CleanupStack::Pop( 2 ); // closing iConn and iSockServ
        // End of atomic part.
        }
    else
        {
        // Not expecting this to be called in other states.
        }

    iParentStatus = aStatus;
    *iParentStatus = KRequestPending;

    if ( !IsActive() )
        {
        // Unless we have an outstanding connect request (iConn.Start),
        // we are done.
        User::RequestComplete( iParentStatus, iStatus.Int() );
        iParentStatus = NULL;
        }
    }

// ---------------------------------------------------------
// CDrmUdtConn::Close()
// ---------------------------------------------------------
//
void CDrmUdtConn::Close()
    {
    LOG( _L("CDrmUdtConn::Close") );
    Cancel();
    iConnection.Close();
    iSocketServ.Close();
    iState = EInit;
    }

// ---------------------------------------------------------
// CDrmUdtConn::IsConnected()
// ---------------------------------------------------------
//
TBool CDrmUdtConn::IsConnected( TUint32& aIap )
    {
    LOG( _L("CDrmUdtConn::IsConnected") );
    TBool connected( EFalse );
    if( iState == EConnected )
        {
        TBuf<KCommsDbSvrMaxColumnNameLength * 2 + 1> iapId;
        _LIT( KFormatIapId, "%S\\%S" );
        TPtrC iap( IAP );
        TPtrC id( COMMDB_ID );
        iapId.Format( KFormatIapId, &iap, &id );
        TInt err = iConnection.GetIntSetting( iapId, aIap );
        connected = err ? EFalse : ETrue;
        }
    return connected;
    }

// ---------------------------------------------------------
// CDrmUdtConn::CConnection()
// ---------------------------------------------------------
//
CDrmUdtConn::CDrmUdtConn()
: CActive( CActive::EPriorityStandard ),
  iState( EInit )
    {
    LOG( _L("CDrmUdtConn::CDrmUdtConn") );
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------
// CDrmUdtConn::ConstructL()
// ---------------------------------------------------------
//
void CDrmUdtConn::ConstructL()
    {
    LOG( _L("CDrmUdtConn::ConstructL") );
    /*
    TUint32 APs( 0 );
    CCommsDatabase* commsdb = CCommsDatabase::NewL( EDatabaseTypeIAP );
    CleanupStack::PushL( commsdb );
    CApSelect* apSel = CApSelect::NewLC (
        *commsdb,
        KEApIspTypeAll,
        EApBearerTypeAll,
        KEApSortUidAscending );
    APs = apSel->Count();
    CleanupStack::PopAndDestroy( 2 );
    if ( !APs )
        {
        // No AP defined
        User::Leave( KErrRoapGeneral );
        }
     */
    }

// ---------------------------------------------------------
// CDrmUdtConn::DoCancel()
// ---------------------------------------------------------
//
void CDrmUdtConn::DoCancel()
    {
    LOG( _L("CDrmUdtConn::DoCancel") );
    iConnection.Close();
    iSocketServ.Close();
    User::RequestComplete( iParentStatus, KErrCancel );
    }

// ---------------------------------------------------------
// CDrmUdtConn::RunL()
// ---------------------------------------------------------
//
void CDrmUdtConn::RunL()
    {
    LOG( _L("CDrmUdtConn::RunL") );
    User::LeaveIfError( iStatus.Int() );    // Handle errors in RunError().

    iState = EConnected;
    User::RequestComplete( iParentStatus, iStatus.Int() );
    iParentStatus = NULL;
    }

// ---------------------------------------------------------
// CDrmUdtConn::RunError()
// ---------------------------------------------------------
//
TInt CDrmUdtConn::RunError( TInt  /*aError*/ )
    {
    LOG( _L("CDrmUdtConn::RunError") );
    iConnection.Close();
    iSocketServ.Close();
    iState = EInit;
    User::RequestComplete( iParentStatus, iStatus.Int() );
    iParentStatus = NULL;
    return KErrNone;
    }

// ---------------------------------------------------------
// CRoapConnection::Conn()
// ---------------------------------------------------------
//
RSocketServ& CDrmUdtConn::SocketServ()
    {
    LOG( _L("CDrmUdtConn::SocketServ") );
    return iSocketServ;
    }

// ---------------------------------------------------------
// CRoapConnection::Conn()
// ---------------------------------------------------------
//
RConnection& CDrmUdtConn::Conn()
    {
    LOG( _L("CDrmUdtConn::Conn") );
    return iConnection;
    }