/*

* 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: 

*     This class provides connection/session related information.

*	  Both the requested and the stored AP's are here.

*

*

*/

//INCLUDE FILES

	//System Includes

#include <bldvariant.hrh>

#include <ApAccessPointItem.h>

#include <AknNotifyStd.h>

#include <AknGlobalNote.h>

#include <e32std.h>

#include <ApUtils.h>

#include <ApDataHandler.h>

#include <cdbstore.h>

#include <coemain.h>

#include <bautils.h>

#include <connectionmanager.rsg>

#include <Avkon.rsg>

#include <cdblen.h>

#include <StringLoader.h>

#include <connectprog.h>

#include <nd_err.h>

#include <etelmm.h>

#include <data_caging_path_literals.hrh>

#include <AknsUtils.h> 

#include <avkon.mbg>

#include <ConnMan.mbg>

#include <rconnmon.h>

#include <ConnectionUiUtilities.h>

#include <AknQueryDialog.h>

#include <WlanCdbCols.h>

#include <etelpckt.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <commsdat.h>

	//User Includes

#include "InternetConnectionManager.h"

using namespace CMManager;

// CONSTANTS

_LIT(KConnectionResourceFile, "\\resource\\ConnectionManager.rsc");

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

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

//CInternetConnectionManager::ConnectL( TUint32 aIAPId1, TUint32 aIAPId2 )

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

EXPORT_C TInt CInternetConnectionManager::ConnectL(  TUint32 /*aIAPId1*/, TUint32 /*aIAPId2*/ )

	{

    User::Panic( KNullDesC, KErrNotSupported );

	return KErrGeneral;

	}

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

//CInternetConnectionManager::ConnectL( TUint32 aIAPId1 )

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

EXPORT_C TInt CInternetConnectionManager::ConnectL( TUint32 aIAPId )

	{

	//1) Check whether AP exists

	//2) Check CSD coverage

	//3) Check GPRS coverage

	//4) Check Whether a connection already exists

    CLOG_WRITE_1( "CInternetConnectionManager::ConnectL - %d", aIAPId );

	// GPRS available

	iInternalError = KErrNone;

	iNewConnectionEstablished = EFalse;

	TInt connErr( KErrNone );

	connErr = ConnectWithoutCheckL( aIAPId );

    DisplayConnErrorL();

	return connErr;

	}

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

//CInternetConnectionManager::ConnectWithoutCheckL( TUint32 aIAPId1 )

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

TInt CInternetConnectionManager::ConnectWithoutCheckL( TUint32 aIAPId )

	{

    CLOG_ENTERFN( "ConnectWithoutCheckL" );

	iInternalError = KErrNone;

	TInt connErr;

	//Do the connection

    TCommDbConnPref pref;

	TBool gprsCovered( ETrue );

	if( !CheckNetworkL( gprsCovered ) )

		{

		//show that there is no coverage!

		ShowGlobalNoteL( EAknGlobalErrorNote, R_EXT_ERR_NO_NETWORK_COVER );

		connErr = KErrGeneral;

		}

	else //there is coverage			

		{

        TBool IsApGprs( EFalse );

		IsApGprs = BearerTypeL( aIAPId ) == EApBearerTypeGPRS;

		if( !iRequestedAPIds.iFirstPreference )

		    {

		    pref.SetDialogPreference( ECommDbDialogPrefPrompt );

		    }

		else

		    {

            pref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

		    }

		if( gprsCovered || !IsApGprs  )

			{

            pref.SetIapId( aIAPId );

            if( !iSilentMode && iRequestedAPIds.iFirstPreference )

                // Temp fix for CDMA 

                {

                if( IsApGprs )

                    {

                    pref.SetBearerSet( ECommDbBearerGPRS );

                    }

                else

                    {

                    pref.SetBearerSet( ECommDbBearerCSD );

                    }

                }

            if (BearerTypeL( aIAPId ) == EApBearerTypeAllBearers)

            	{

            		pref.SetBearerSet( ECommDbBearerCSD |

									   ECommDbBearerPSD | // includes both KCommDbBearerWcdma and KCommDbBearerCdma2000. ECommDbBearerGPRS is ECommDbBearerWcdma

									   ECommDbBearerLAN |

									   ECommDbBearerVirtual |

									   ECommDbBearerPAN |

									   ECommDbBearerWLAN );

            	}

			connErr = ConnectL( pref );

			}

		else //there is no gprs coverage and the AP needs it!!!

			{

			//show that there is no coverage!!!

			ShowGlobalNoteL( EAknGlobalErrorNote, R_EXT_ERR_NO_NETWORK_COVER );

			connErr = KErrGeneral;

			}

		}

    if( connErr == KErrNone )

        {

        iConnected = ETrue;

        // Enable connection cloning        

        _LIT_SECURITY_POLICY_C2(KProcPolicy1, ECapabilityNetworkServices, ECapabilityNetworkControl);

        TSecurityPolicyBuf secPolBuf;

        secPolBuf().Set(KProcPolicy1().Package());

        iConnection.Control(KCOLConnection, KCoEnableCloneOpen, secPolBuf);

        if( iSilentMode )

            // Temp fix for CDMA

            {

            TUint32 iapId;

            TBuf<20> query;

            TBuf<40> val;

            query.Format( _L("%s\\%s"), IAP, COMMDB_ID );

            User::LeaveIfError( iConnection.GetIntSetting( query, iapId ) );

            iCurrentAP = (CApAccessPointItem*)iapId;

            query.Format(_L("%s\\%s"), IAP, COMMDB_NAME);

            User::LeaveIfError( iConnection.GetDesSetting( query, val ) );

            iConnName = val.AllocL();

            }

        else if( !iRequestedAPIds.iFirstPreference )

            {

            TBuf<20> query;

            TBuf<40> val;

            query.Format( _L("%s\\%s"), IAP, COMMDB_ID );

            User::LeaveIfError( iConnection.GetIntSetting( query, iRequestedAPIds.iFirstPreference ) );

#ifndef __WINS__

            CApAccessPointItem* ap = APItemFromIAPIdLC( iRequestedAPIds.iFirstPreference );

		    UpdateCurrentAPL( *ap, EFalse );

		    CleanupStack::PopAndDestroy();  // ap

#endif

            query.Format(_L("%s\\%s"), IAP, COMMDB_NAME);

            User::LeaveIfError( iConnection.GetDesSetting( query, val ) );

            iConnName = val.AllocL();

            }

        else

            {

#ifndef __WINS__

            CApAccessPointItem* ap = APItemFromIAPIdLC( aIAPId );

		    UpdateCurrentAPL( *ap, EFalse );

		    CleanupStack::PopAndDestroy();  // ap

#endif

            }

        StartConnectionObservingL();

        }

	return connErr;

	}

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

//CInternetConnectionManager::ConnectWithoutCheckL( TUint32 aIAPId1 )

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

TInt CInternetConnectionManager::ConnectWithoutCheckL( TUint32 /*aIAPId1*/, TUint32 /*aIAPId2*/ )

	{

    User::Panic( KNullDesC, KErrNotSupported );

	return KErrGeneral;

	}

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

//CInternetConnectionManager::DisplayConnErrorL

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

void CInternetConnectionManager::DisplayConnErrorL()

	{

	CLOG_ENTERFN("DisplayConnErrorL");

	if ( iInternalError && !iSilentMode && iInternalError!= KErrCancel && IsConnectionAllowedL( EFalse ) )

		{

		CLOG_WRITE("Some Error should be shown");

		CLOG_WRITE_1("Error %d", iInternalError);

		//filtering out errors that are shown by the phone app

        if( iInternalError == KErrEtelCallAlreadyActive ||

            iInternalError == KErrEtelBusyDetected )

            {

            ShowErrorNoteL( iInternalError );

            }

        else if ( !InIntArray( KNumsOfDontShowErrors, KADontShowErrors, iInternalError ) )

			{

			CLOG_WRITE("Error is shown by ConnMan");

			if ( !InIntArray( KNumsOfExcludeFromConverting , 

							  KAExcludeFromConverting, 

							  iInternalError )

				&&	( iInternalError == KErrGeneral || iInternalError == KErrCommsLineFail 

				|| KEtelExtErrIntervalLow < iInternalError && iInternalError < KEtelExtErrIntervalHigh 

				|| KGsmErrIntervalLow < iInternalError && iInternalError < KGsmErrIntervalHigh 

				|| KEtelCoreErrIntervalLow < iInternalError && iInternalError < KEtelCoreErrIntervalHigh

				)  )

				{

				CLOG_WRITE("KErrExitModemError");

				ShowErrorNoteL( KErrExitModemError );

				}

			else

				{

                    if (iInternalError == KErrNotFound ) 

				    {

				        // Since -1 is an error from bottom layer with no more information

				        // The good match using "Extended Error Handling" of UI spec would 

				        // be "connection not available". 

                        ShowErrorNoteL(NW_STAT_WPS_ERROR, CTextResolver::ECtxNoCtxNoSeparator);                         

				    }

				    else 

				    {

					    ShowErrorNoteL( iInternalError );

				    }

				}

			}

		}

    else

        {

        if( !IsConnectionAllowedL( EFalse ) )

            {

            CLOG_WRITE("Operation is not allowed in off-line mode");

            ShowGlobalNoteL( EAknGlobalInformationNote, R_QTN_OFFLINE_NOT_POSSIBLE );

            iInternalError = KErrGeneral;

            }

        }

    }

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

//CInternetConnectionManager::NewL

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

EXPORT_C CInternetConnectionManager* CInternetConnectionManager::NewL( TBool aSilentMode )

	{

    CInternetConnectionManager* self = CInternetConnectionManager::NewLC( aSilentMode );

	CleanupStack::Pop();

	return self;

	}

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

//CInternetConnectionManager::NewL

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

EXPORT_C CInternetConnectionManager* CInternetConnectionManager::NewL( CCommsDatabase* aCommsDb, TBool aSilentMode )

	{

	CInternetConnectionManager* self = CInternetConnectionManager::NewLC( aCommsDb, aSilentMode );

	CleanupStack::Pop();

	return self;

	}

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

//CInternetConnectionManager::NewLC

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

EXPORT_C CInternetConnectionManager* CInternetConnectionManager::NewLC( TBool aSilentMode )

	{

	CInternetConnectionManager*  self = new( ELeave )CInternetConnectionManager( aSilentMode );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

//CInternetConnectionManager::NewLC

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

EXPORT_C CInternetConnectionManager* CInternetConnectionManager::NewLC( CCommsDatabase* aCommsDb, TBool aSilentMode )

	{

    CInternetConnectionManager*  self = new( ELeave )CInternetConnectionManager( aCommsDb, aSilentMode );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

//CInternetConnectionManager::ConnectL

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

TInt CInternetConnectionManager::ConnectL

	(

    TCommDbConnPref& /*aPref1*/,

    TCommDbConnPref& /*aPref2*/

	)

	{

    User::Panic( KNullDesC, KErrNotSupported );

	return KErrGeneral;

	}

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

//CInternetConnectionManager::ConnectL

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

TInt CInternetConnectionManager::ConnectL

	(

    TCommDbConnPref& aPref1

	)

	{

	if ( iAlreadyInUse )

		{

		CLOG_WRITE( "Reentering happend, calling User::Leave!!!" );

		User::Leave( KErrAlreadyExists );

		}

	iAlreadyInUse = ETrue;

	iInternalError = KErrNone;

	iCalledFromProcessFinish = EFalse;

	TInt connErr( KErrNone );

	CLOG_WRITE( "ConnMan: Setting overides" );

		//Leave point

    TCommDbConnPref *overrides = new (ELeave) TCommDbConnPref;

	CleanupStack::PushL( overrides );

    // there's no copy constructor thus 

    // I need to make a copy of this object manually

    overrides->SetDialogPreference( aPref1.DialogPreference() );

    // Because from 2.0 there is only browser who integrates

    // connection manager there's no need for prompt

    // browser always sets valid access point id.

//    __ASSERT_DEBUG( aPref1.IapId(), User::Panic( KNullDesC, KErrArgument ) ); // Temp for CDMA fix

    // set access point id in overrides

    overrides->SetIapId( aPref1.IapId() );

    overrides->SetBearerSet( aPref1.BearerSet() );

    TInt connAllowed( ETrue );

    TInt err = 

        iRepository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed);

    CLOG_WRITE_1( "ConnMan connAllowed: %d", connAllowed );

    if( !connAllowed && ( KErrNone == err ) )

        {

        CLOG_WRITE( "ConnMan SetBearerSet: ECommDbBearerWLAN"  );

        overrides->SetBearerSet( ECommDbBearerWLAN );

        }

	//TUint32 bearer = aPref1.BearerSet();

	CLOG_WRITE( "ConnMan Overrides set"  );

//>>>>>>>>>>>

    if ( !iSilentMode && !connErr )

		{

		CLOG_WRITE( "ConnMan: Starting Wait dlg with name" );

		HBufC* buf = NULL;

		if( aPref1.IapId() )

		    {

        	buf = StringLoader::LoadL

        				( 

        				R_ICS_WAIT_CONNECTING, 

        				*APNameLC( aPref1.IapId() )

        				);

        	CleanupStack::PushL( buf );

		    }

		CLOG_WRITE( "Calling StartWaitDialogL" );

		StartWaitDialogL( buf, EWaitGPRSIcon );

		CLOG_WRITE( "StartWaitDialogL returned with no leave" );

        if( aPref1.IapId() )

		    {		

		    CleanupStack::PopAndDestroy( 2 );//buf, HBuf* returned by APNameLC	

		    }

		}

//>>>>>>>>>>>

	if ( !connErr )

		{

		TBool alreadyCancelled = ( !iSilentMode && !iWaitDialog );

		if ( alreadyCancelled )

			{

			connErr = KErrCancel;

			}

		else

			{               

		        connErr = iConnection.Open( iServ, KAfInet );

		        CLOG_WRITE_1( "RConnection: %d", connErr );

		        if( connErr == KErrNone )

		            {

		            // Always pass the IAP Id to RConnection even in silent mode

		            connErr = iSyncConnector->Connect( overrides );

		            }

		        if( connErr != KErrNone )

		            {

		            CLOG_WRITE( "Closing all" );

		            iConnection.Close();

		            }

			}

		}

	if ( iWaitDialog )

		{

		CLOG_WRITE(  "Killing wait dialog..." );

		iCalledFromProcessFinish = ETrue;

		iWaitDialog->ProcessFinishedL();

		CLOG_WRITE(  "ProgressFinished is called" );

		}

	CleanupStack::PopAndDestroy();//overrides

    	iInternalError = connErr;

	CLOG_WRITE_1( "ConnectL returned with %d", connErr );

	iNewConnectionEstablished = ( connErr == KErrNone );

	iAlreadyInUse = EFalse;

	return connErr;

	}

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

//CInternetConnectionManager::~CInternetConnectionManager

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

CInternetConnectionManager::~CInternetConnectionManager()

	{

	CLOG_WRITE("Destructor");

    Disconnect();

    delete iStageNotifier;

    iMobilePhone.Close();

    iTelServer.Close();

    delete iRepository;

	if( !iSilentMode )

		{

		CCoeEnv::Static()->DeleteResourceFile( iResOffset );

		}

    delete iVpnEngine;

    delete iApDataHandler;

	delete iApUtils;

	delete iNote;

	if ( iCommsDbOwned )

		{

		delete iCommsDb;

		}

    if( iConnected )

        {

        iConnection.Close();

        }

    if( !iSilentMode )

        // Temp fix for CDMA

        {

        delete iCurrentAP;

        }