/*

 * Copyright (c) 2010 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:  Connection manager for DRM

 *

 */

// INCLUDE FILES

#include <es_sock.h>

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmmanager.h>

#include <extendedconnpref.h>

#include <cmapplicationsettingsui.h> // CCmApplicationSettingsUi

#include <es_enum.h>

#include <cdbcols.h> // IAP, COMMDB_ID

#include "drmutilityconnection.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "drmutilityconnectionTraces.h"

#endif

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

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

// HasDefaultConnectionL

// Finds default IAP id

// @return Etrue: valid AP found

//         EFalse: valid AP not found

// @leave system wide error codes

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

//

TBool DRM::CDrmUtilityConnection::HasDefaultConnectionL()

    {

    TBool hasDefault(EFalse);

    TCmDefConnValue defConn;

    RCmManager cmManager;

    cmManager.OpenLC();

    cmManager.ReadDefConnL(defConn);

    if (defConn.iType == ECmDefConnConnectionMethod)

        {

        cmManager.GetConnectionMethodInfoIntL(defConn.iId,

                CMManager::ECmIapId);

        hasDefault = ETrue;

        }

    else if (defConn.iType == ECmDefConnDestination)

        {

        RCmDestination dest(cmManager.DestinationL(defConn.iId));

        CleanupClosePushL(dest);

        if (dest.ConnectionMethodCount() <= 0)

            {

            User::Leave(KErrNotFound);

            }

        RCmConnectionMethod cMeth(dest.ConnectionMethodL(0));

        CleanupClosePushL(cMeth);

        cMeth.GetIntAttributeL(CMManager::ECmIapId);

        CleanupStack::PopAndDestroy(&cMeth);

        CleanupStack::PopAndDestroy(&dest);

        hasDefault = ETrue;

        }

    CleanupStack::PopAndDestroy(&cmManager);

    return hasDefault;

    }

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

// CDrmUtilityConnection::HasAccessPointsL

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

//

TBool DRM::CDrmUtilityConnection::HasAccessPointsL()

    {

    TInt apCount(0);

    RCmManager cmManager;

    CleanupClosePushL(cmManager);

    cmManager.OpenL();

    RArray<TUint32> aps;

    CleanupClosePushL(aps);

    cmManager.ConnectionMethodL(aps, EFalse, EFalse, ETrue);

    apCount = aps.Count();

    CleanupStack::PopAndDestroy(2, &cmManager); //aps, cmManager

    return apCount > 0;

    }

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

// DRM::CDrmUtilityConnection::NewLC

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

//

DRM::CDrmUtilityConnection* DRM::CDrmUtilityConnection::NewLC(

        const TBool aAllowQueries)

    {

    CDrmUtilityConnection* conn = new (ELeave) CDrmUtilityConnection(

            aAllowQueries);

    CleanupStack::PushL(conn);

    conn->ConstructL();

    return conn;

    }

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

// DRM::CDrmUtilityConnection::NewL

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

//

DRM::CDrmUtilityConnection* DRM::CDrmUtilityConnection::NewL(

        const TBool aAllowQueries)

    {

    CDrmUtilityConnection* conn = CDrmUtilityConnection::NewLC(aAllowQueries);

    CleanupStack::Pop(conn);

    return conn;

    }

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

// DRM::CDrmUtilityConnection::~CDrmUtilityConnection

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

//

DRM::CDrmUtilityConnection::~CDrmUtilityConnection()

    {

    Cancel();

    iConnection.Close();

    iSocketServ.Close();

    }

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

// DRM::CDrmUtilityConnection::ConnectL

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

//

void DRM::CDrmUtilityConnection::ConnectL(TRequestStatus* aStatus)

    {

    TInt error(KErrGeneral);

    iStatus = KRequestPending;

    if (iState == EInit)

        {

        // Make this part atomic by pushing closes on the stack.

        error = iSocketServ.Connect();

        if (!error)

            {

            error = iConnection.Open(iSocketServ);

            }

        }

    if (iState == EConnected)

        {

        error=iConnection.Stop();

        //error=iConnection.Stop(RConnection::EStopAuthoritative); //just in case still does not work

        // if autoriative stop does not work then must do something following follow

        // TNifProgressBuf iJalla;

        // loop iConnection.ProgressNotification(iJalla,iStatus,KConnProgressDefault); SetActive

        // at RunL if (iJalla.iStage < KConnectionDown)

        // reactiveteWaitClose();

        //iConnection.ProgressNotification(iJalla,iStatus,(KConnectionDown); (should loop till state KConnectionDown seen)

        iConnection.Close();

        iState = EInit;

        error = KErrNone;

        error = iConnection.Open(iSocketServ);

        }

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    CompleteSelf(error);

    }

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

// DRM::CDrmUtilityConnection::HasMoreConnectionAttempts

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

//

TBool DRM::CDrmUtilityConnection::HasMoreConnectionAttempts()

    {

    TBool ret(EFalse);

    switch (iType)

        {

        case EUsingPurposeInternet:

            if (iAllowQueries)

                {

                ret = ETrue;

                }

            else

                {

                ret = EFalse;

                }

            break;

        case EUsingQuery:

        case EFail:

            ret = EFalse;

            break;

        default:

            ret = ETrue;

        }

    return ret;

    }

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

// DRM::CDrmUtilityConnection::IsConnected

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

//

TBool DRM::CDrmUtilityConnection::IsConnected(TUint32& aIap)

    {

    TBool ret(EFalse);

    if (iState == EConnected)

        {

        aIap = iIapId;

        ret = ETrue;

        }

    return ret;

    }

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

// DRM::CDrmUtilityConnection::Close

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

//

void DRM::CDrmUtilityConnection::Close()

    {

    //LOGLIT( "CDrmUtilityConnection::Close" )

    Cancel();

    iConnection.Close();

    iSocketServ.Close();

    iState = EInit;

    }

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

// DRM::CDrmUtilityConnection:CDrmUtilityConnection:

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

//

DRM::CDrmUtilityConnection::CDrmUtilityConnection(const TBool aAllowQueries) :

    CActive(CActive::EPriorityStandard), iState(EInit),

            iType(EAttachExisting), iAllowQueries(aAllowQueries)

    {

    CActiveScheduler::Add(this);

    }

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

// DRM::CDrmUtilityConnection::ConstructL

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

//

void DRM::CDrmUtilityConnection::ConstructL()

    {

    }

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

// DRM::CDrmUtilityConnection::DoCancel

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

//

void DRM::CDrmUtilityConnection::DoCancel()

    {

    iConnection.Close();

    iSocketServ.Close();

    CompleteParent(KErrCancel);

    }

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

// DRM::CDrmUtilityConnection::RunL

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

//

void DRM::CDrmUtilityConnection::RunL()

    {

    TInt error(iStatus.Int());

    if (iState == EInit)

        {

        User::LeaveIfError(error); // Handle errors in RunError().

        if (iType == EAttachExisting)

            {

            AttachExistingConnectionL();

            }

        else

            {

            iState = EConnecting;

            error = KErrNotFound;

            CompleteSelf(error);

            }

        }

    else if (iState == EConnecting)

        {

        if (!error)

            {

            iState = EConnected;

            CompleteSelf(error);

            }

        else if (error != KErrNotFound)

            {

            User::LeaveIfError(error);

            }

        else

            {

            switch (iType)

                {

                case EAttachExisting:

                    iType = EUsingDefault;

                    ConnectUsingDefaultL();

                    break;

                case EUsingDefault:

                    iType = EUsingPurposeOperator;

                    ConnectUsingSnapPurposeL(CMManager::ESnapPurposeOperator);

                    break;

                case EUsingPurposeOperator:

                    iType = EUsingPurposeInternet;

                    ConnectUsingSnapPurposeL(CMManager::ESnapPurposeInternet);

                    break;

                case EUsingPurposeInternet:

                    iType = EUsingQuery;

                    if (iAllowQueries)

                        {

                        ConnectUsingQueryL();

                        break;

                        }

                case EUsingQuery:

                    iType = EFail;

                case EFail:

                default:

                    User::Leave(KErrCouldNotConnect);

                    break;

                }

            }

        }

    else if (iState == EConnected)

        {

        UpdateIapIdL();

        CompleteParent(iStatus.Int());

        }

    }

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

// DRM::CDrmUtilityConnection::RunError

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

//

TInt DRM::CDrmUtilityConnection::RunError(TInt aError)

    {

    //LOGLIT( "CDrmUtilityConnection::RunError" )

    iConnection.Close();

    iSocketServ.Close();

    CompleteParent(aError);

    iState = EInit;

    return KErrNone;

    }

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

// DRM::CDrmUtilityConnection::AttachExistingConnectionL

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

//

void DRM::CDrmUtilityConnection::AttachExistingConnectionL()

    {

    TConnectionInfoBuf connInfo;

    TUint count(0);

    TInt error(KErrNotFound);

    iStatus = KRequestPending;

    User::LeaveIfError(iConnection.EnumerateConnections(count));

    if (count)

        {

        // Select AP with largest index. (Latest created)

        User::LeaveIfError(iConnection.GetConnectionInfo(count, connInfo));

        User::LeaveIfError(iConnection.Attach(connInfo,

                RConnection::EAttachTypeNormal));

        iState = EConnected;

        error = KErrNone;

        }

    else

        {

        iState = EConnecting;

        }

    CompleteSelf(error);

    }

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

// DRM::CDrmUtilityConnection::ConnectUsingDefaultL

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

//

void DRM::CDrmUtilityConnection::ConnectUsingDefaultL()

    {

    // Create overrides

    TConnPrefList prefList;

    TExtendedConnPref prefs;

    if (!iAllowQueries)

        {

        prefs.SetNoteBehaviour(TExtendedConnPref::ENoteBehaviourConnSilent);

        }

    else

        {

        prefs.SetNoteBehaviour(TExtendedConnPref::ENoteBehaviourConnDisableQueries);

        }

    //Fetch default connection

    TBool hasDefault(ETrue);

    TCmDefConnValue defConn;

    RCmManager cmManager;

    cmManager.OpenLC();

    cmManager.ReadDefConnL(defConn);

    if (defConn.iType == ECmDefConnConnectionMethod)

        {

        prefs.SetIapId(defConn.iId);

        }

    else if (defConn.iType == ECmDefConnDestination)

        {

        prefs.SetSnapId(defConn.iId);

        }

    else

        {

        hasDefault = EFalse;

        }

    // End of fetch default connection

    CleanupStack::PopAndDestroy(&cmManager);

    if (hasDefault)

        {

        prefList.AppendL(&prefs);

        // Start an Outgoing Connection with overrides

        iState = EConnecting;

        iConnection.Start(prefList, iStatus);

        SetActive();

        }

    else

        {

        // No default found --> next iteration needed

        CompleteSelf(KErrNotFound);

        }

    }

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

// DRM::CDrmUtilityConnection::ConnectUsingSnapOperatorL

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

//

void DRM::CDrmUtilityConnection::ConnectUsingSnapPurposeL(

        const TUint32 aPurpose)

    {

    // Create overrides

    TConnPrefList prefList;

    TExtendedConnPref prefs;

    prefs.SetSnapPurpose(static_cast<CMManager::TSnapPurpose> (aPurpose));

    if (aPurpose != CMManager::ESnapPurposeUnknown)

        {

        if (!iAllowQueries)

            {

            prefs.SetNoteBehaviour(

                    TExtendedConnPref::ENoteBehaviourConnSilent);

            }

        else

            {

            prefs.SetNoteBehaviour(

                    TExtendedConnPref::ENoteBehaviourConnDisableQueries);

            }

        }

    else

        {

        prefs.SetConnSelectionDialog(ETrue);

        prefs.SetNoteBehaviour(TExtendedConnPref::ENoteBehaviourDefault);

        prefs.SetForcedRoaming(EFalse);

        prefs.SetBearerSet(TExtendedConnPref::EExtendedConnBearerUnknown);

        }

    prefList.AppendL(&prefs);

    iState = EConnecting;

    // Start an Outgoing Connection with overrides

    iConnection.Start(prefList, iStatus);

    SetActive();

    }

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

// DRM::CDrmUtilityConnection::ConnectUsingQueryL

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

//

void DRM::CDrmUtilityConnection::ConnectUsingQueryL()

    {

    // Create overrides

    TConnPrefList prefList;

    TExtendedConnPref prefs;

    CCmApplicationSettingsUi* ui(CCmApplicationSettingsUi::NewLC());

    TCmSettingSelection selectedConn;

    TBool selected(ui->RunApplicationSettingsL(selectedConn));

    CleanupStack::PopAndDestroy(ui);

    ui=NULL;

    if (selected)

        {

        if (selectedConn.iResult == CMManager::EConnectionMethod)

            {

            prefs.SetIapId(selectedConn.iId);

            }

        else if (selectedConn.iResult == CMManager::EDestination)

            {

            prefs.SetSnapId(selectedConn.iId);

            }

        else if (selectedConn.iResult != CMManager::EDefaultConnection)

            {

            selected=EFalse;

            }

        }

    if (selected)

        {

        if (selectedConn.iResult != CMManager::EDefaultConnection)

            {

            prefList.AppendL(&prefs);

            // For ensuring possibly stale connections get disconnected first;

            iConnection.Close();

            iConnection.Open(iSocketServ);

            iConnection.Start(prefList, iStatus);

            }

        else

            {

            iConnection.Start(iStatus);

            }

        SetActive();

        }

    else

        {

        CompleteSelf(KErrCancel);

        }

    }

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

// DRM::CDrmUtilityConnection::CompleteSelf