/*

* Copyright (c) 2005-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:    Handles IAP selection and connection permissions.*

*/

/*

IAP selection procedure:

------------------------

Return iCurrentIap if it's feasible:

  1. If Service has EReadOnlyIaps flag set and iCurrentIap is not found from iService

     IAPs, set iCurrentIapIsFeasible to EFalse and jump to section 4.

  2. If iCiAiMatch exists, return it. [EXIT]

  3. If iCurrentIap is EGprs or ECsd type, return it. [EXIT]

  4. Run WLAN scan.

  5. If iCurrentIapIsFeasible is ETrue

    5.1 Calculate iCiSwiMatch

    5.2 If iCiSwiMatch exists, return it. [EXIT]

iCurrentIap wasn't feasible, try to find from service IAPs list:

  6. Put service IAPs to iAvailableIaps list.

  7. Check if WLAN is available, (iActiveIaps has WLAN IAP which is not on service IAPs).

    7.1 If WLAN is not available remove all WLAN IAPS from iAvailableIaps list.

    7.2 Choose best from iAvailableIaps. [EXIT]

  8. Remove all WLAN IAPs from iAvailableIaps list.

  9. Add iSiSwiMatch to iAvailableIaps list.

 10. Choose highest priority from iAvailableIaps. [EXIT]   

Note1: In offline mode hidden WLAN IAPs from service IAPS and current iap

       are added to Scanned WLAN IAPs even if they are not found from the scan.

Note2: If phone is in offline mode, then all EGprs and ECsd IAPs are filtered out

       from iService IAPs and iCurrentIap.

Note3: iCurrentIap is not feasible if service has EReadOnlyIaps flag set and iCurrentIap

       is not found from service IAPs, ie iCiSiMatch does not contain value. 

*/

// INCLUDE FILES

#include "CIptvNetworkSelection.h"

#include "CIptvServer.h"

#include "CIptvServiceManager.h"

#include <cdbcols.h>

#include <WlanCdbCols.h>

#include "IptvDebug.h"

#include <commdb.h>

#include <bldvariant.hrh>

#include <es_enum.h> //TConnectionInfo

#include <in_sock.h>

#include <rconnmon.h>

#include <wlanmgmtcommon.h>

#include <CProfileChangeNotifyHandler.h>

#include <Profile.hrh>

#include <MProfileEngine.h>

#include <cmdestinationext.h>

#include <cmmanagerext.h>

#include <centralrepository.h>

#include <cmpluginwlandef.h> 

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

#ifdef __WINSCW__

const TInt KWlanScanSimulationTimerTime = 5000000; // 5 seconds

#endif

// MACROS

// LOCAL CONSTANTS AND MACROS

#if IPTV_LOGGING_METHOD != 0

_LIT(KIptvNsWlan, "EWlan");

_LIT(KIptvNsGprs, "EGprs");

_LIT(KIptvNsCsd, "ECsd");

_LIT(KIptvNsUnknown, "EUnknown");

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CIptvNetworkSelection::CIptvNetworkSelection

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIptvNetworkSelection::CIptvNetworkSelection( CIptvServer& aServer )

:CActive(EPriorityStandard), iServer(aServer)

    {

    }

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

// CIptvNetworkSelection::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvNetworkSelection::ConstructL()

    {

#ifdef __WINSCW__

    iWlanScanSimulationTimer = CIptvTimer::NewL( EPriorityStandard, *this );

#endif

    CActiveScheduler::Add( this );

    iGetUsedIapReqs.Reset();

		//Initialize iOffline

		MProfileEngine* engine = CreateProfileEngineL();

		CleanupReleasePushL( *engine );

    if ( engine )

        {

        if ( engine->ActiveProfileId() == EProfileOffLineId )

            {

            iOffline = ETrue;	

            }

        else

            {

            iOffline = EFalse;

            }

        }

    CleanupStack::PopAndDestroy( engine );  

    iProfChangeHandler = CProfileChangeNotifyHandler::NewL( this ); 

    }

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

// CIptvNetworkSelection::NewL

// Two-phased constructor.

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

//

CIptvNetworkSelection* CIptvNetworkSelection::NewL( CIptvServer& aServer )

    {

    CIptvNetworkSelection* self = new( ELeave ) CIptvNetworkSelection( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CIptvNetworkSelection::~CIptvNetworkSelection()

    {

    Cancel();

    delete iActiveIaps;

    delete iScannedWlanIaps;

    delete iAvailableIaps;

    iGetUsedIapReqs.Close();

    iConnMon.Close();

#ifdef __WINSCW__

    delete iWlanScanSimulationTimer;

#endif

    delete iProfChangeHandler;

    delete iService;

    }

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

// CIptvNetworkSelection::SetUsedIap

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

//

void CIptvNetworkSelection::SetUsedIapL( TUint32 aIapId,

                                         TUint32 aServiceId,

                                         TBool aSetToDefaultForService,

                                         TRespStatus& aRespStatus )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetUsedIapL() start");

    IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: setting %d as a current IAP in use.", aIapId);

    iCurrentIap.iId          = aIapId;

    iCurrentIap.iValueExists = ETrue;

    if ( aSetToDefaultForService )

        {

        IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: adding to services' (%d) iap list too", aServiceId);

        CIptvService* service = iServer.iServiceManager->GetServiceL( aServiceId, ETrue /* do open/close */ );

        if ( !service )

            {

            IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: service not found: %d", aServiceId);

            aRespStatus = EServiceNotFound;

            return;

            }

        CleanupStack::PushL( service );         // 1->

        TInt i;

        TBool zeroPrioExists   = EFalse;

        //try to delete iap if its there already

        TIptvIap iap;

        iap.iId       = aIapId;

        iap.iPriority = 0; //0 = the highest priority (king), prio has no effect on delete

        TInt err = service->iIapList->DeleteIap( iap );

        if ( err == KErrNone )

            {

            IPTVLOGSTRING2_LOW_LEVEL("CIptvNetworkSelection:: There was already iap with id %d, deleted it", aIapId);

            }

        else

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: iap did not exist, didn't delete");

            }

        //move up priorities if there is priority 0 iap already

        for ( i = 0; i < service->iIapList->Count(); i++ )

            {

            if ( service->iIapList->IapL(i).iPriority == 0 )

                {

                IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: There was already prio 0");

                zeroPrioExists = ETrue;

                break;

                }

            }

        if ( zeroPrioExists )

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: adding +1 to all priorities");

            for ( i = 0; i < service->iIapList->Count(); i++ )

                {

                service->iIapList->IapL(i).iPriority += 1; 

                }            

            }

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: adding new IAP with prio 0");

        service->iIapList->AddIap( iap );

        iServer.iServiceManager->UpdateServiceL( *service );

        CleanupStack::PopAndDestroy( service ); // <-1

        }

    aRespStatus = ESucceeded;

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::SetUsedIapL() exit");

    }

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

// CIptvNetworkSelection::GetUsedIapReqL

// Called by Network Selection client

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

//

void CIptvNetworkSelection::GetUsedIapReqL( TIptvGetUsedIapReq* aGetUsedIapReq )

    {

    UpdateServiceL( aGetUsedIapReq->iServiceId );

    if ( !iService )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * No such service, aborting *");

        aGetUsedIapReq->iRespStatus = EServiceNotFound;

        return;

        }

    TInt destId( 0 );

    TBool invalidDest( EFalse );

    CRepository* cenRep = CRepository::NewLC( KIptvAlrCenRepUid );

    if ( cenRep->Get( KIptvCenRepUsedSnapIdKey, destId ) != KErrNone )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey not found *");

        aGetUsedIapReq->iRespStatus = static_cast<TUint8>( ENoSuitableIapFound );

        invalidDest = ETrue;

        }

    else if ( destId == KIptvCenRepAPModeAlwaysAsk )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey always ask");

        aGetUsedIapReq->iRespStatus = static_cast<TUint8>( EFailedAlwaysAskSelected );

        invalidDest = ETrue;

        }

    CleanupStack::PopAndDestroy( cenRep );

    // Scan is useless, when always ask is selected.

    if ( invalidDest  && !( (iService->GetFlags() & CIptvService::EReadOnlyIaps ) ) )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: ALR//Always ask mode on or key not found");

        return;

        }

    if ( (iService->GetFlags() & CIptvService::EReadOnlyIaps) )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * service has read only iaps *");

        }

    aGetUsedIapReq->iRespStatus = EProcessing;

    UpdateAllButWlanListsL( *aGetUsedIapReq );

    //informs client that response will arrive asyncrounously to callback function

    aGetUsedIapReq->iRespStatus = EDoingWlanScan;

    //add TIptvGetUsedIapReq to list

    iGetUsedIapReqs.AppendL( aGetUsedIapReq );

#ifdef __WINSCW__

    //use timer to simulate event receiving

    iWlanScanSimulationTimer->Cancel();

    iWlanScanSimulationTimer->After( KWlanScanSimulationTimerTime );

#else

    if ( !IsActive() )

        {

        UpdateWlanScannedIapsL(); //async

        }

#endif

    //Now we just wait call to RunL() (or TimerExpired() on WINSCW),

    //RunL() converts SSIDS to IAPS and calls HandleGetUsedIapRequests()

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetUsedIapReqL() exit");

    return;

    }

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

// CIptvNetworkSelection::HandleGetUsedIapRequests

// Called by RunL() when wlan scan has finished

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

// 

void CIptvNetworkSelection::HandleGetUsedIapRequests()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::HandleGetUsedIapRequests() start");

    TInt i;

    for ( i = 0; i < iGetUsedIapReqs.Count(); i++ )

        {

        TRAPD( err, GetUsedIapAfterWlanScanL( *(iGetUsedIapReqs[i]) ) );

        if ( err == KErrNone )

            {

            //inform the request owner

            iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] );

            }

        else

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * failed to get used iap after wlan scan! *");

            iGetUsedIapReqs[i]->iRespStatus = static_cast<TUint8>(EGeneralError);

            iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] );

            }

        }

    iGetUsedIapReqs.Close(); //delete request items

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::HandleGetUsedIapRequests() exit");

    }

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

// CIptvNetworkSelection::CancelGetUsedIapReq

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

// 

TInt CIptvNetworkSelection::CancelGetUsedIapReq( MIptvNetworkSelectionObserver* aObserver )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CancelGetUsedIapReq() start");

    TInt i;

    if ( iGetUsedIapReqs.Count() == 0 )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: no requests pending.");

        return KErrNotFound;

        }

    TBool found = EFalse;    

    for ( i = 0; i < iGetUsedIapReqs.Count() && !found; i++ )

        {

        if ( iGetUsedIapReqs[i]->iNsObserver == aObserver )

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: request removed, cancel resp sent.");

            iGetUsedIapReqs[i]->iRespStatus = static_cast<TUint8>(ECancelled);

            iGetUsedIapReqs[i]->iNsObserver->GetUsedIapResp( iGetUsedIapReqs[i] );

            iGetUsedIapReqs.Remove( i );

            found = ETrue;

            }

        }

    if ( iGetUsedIapReqs.Count() == 0 )

        {

#ifdef __WINSCW__

        IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: this was the last request, cancel wlan scan simulation timer (WINSCW only).");

        iWlanScanSimulationTimer->Cancel();

#else

        // Cancel wlan scan

        Cancel();

        iGetUsedIapReqs.Close();

#endif        

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::CancelGetUsedIapReq() exit");

    if ( !found )

        {

        return KErrNotFound;

        }

    else

        {

        return KErrNone;

        }

    }

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

// CIptvNetworkSelection::GetUsedIapAfterWlanScanL

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

//

void CIptvNetworkSelection::GetUsedIapAfterWlanScanL( TIptvGetUsedIapReq& aGetUsedIapReq )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection::GetUsedIapAfterWlanScanL() start");

    //we update these again, AI might have changed

    UpdateAllButWlanListsL( aGetUsedIapReq );

#ifndef __WINSCW__  // wlan stuff is not needed in winscw

    // Note: This iOffLine check was added to fix the error TSIN-6YTDSJ 

    // "Video Center tries to connect via unavailable WLAN when refreshing

    // video feed". In online mode the RConnectionMonitor does return the

    // correct status of hidden WLAN APs so there is no need to add them

    // manually. Manual addition is needed only in offline mode where platform

    // cannot sniff for hidden APs (user authorisation would be required).

    if ( iOffline )

        {

        AddHiddenWlanSiIapsToSwiL();

        }

#endif

    // ALR defined

    // Used iap selected from SNAP with highest priority.

    RCmManagerExt manager;

	manager.OpenL();

	CleanupClosePushL( manager );

	TInt destId( 0 );

	CRepository* cenRep = CRepository::NewLC( KIptvAlrCenRepUid );

	if( cenRep->Get( KIptvCenRepUsedSnapIdKey, destId ) != KErrNone )

		{

		IPTVLOGSTRING_LOW_LEVEL("CIptvNetworkSelection:: * KIptvCenRepUsedSnapIdKey not found *");

		CleanupStack::PopAndDestroy( cenRep );

		CleanupStack::PopAndDestroy( &manager );

		aGetUsedIapReq.iRespStatus = static_cast<TUint8>(ENoSuitableIapFound);

		return;

		}

	CleanupStack::PopAndDestroy( cenRep );

	// Check if read only iaps

	if ( ( iService->GetFlags() & CIptvService::EReadOnlyIaps ) )

	    {

	    delete iAvailableIaps;

        iAvailableIaps = NULL;

        iAvailableIaps = CIptvIapList::NewL();

        TInt i;

#ifndef __WINSCW__

        for ( i = 0; i < iScannedWlanIaps->Count(); i++ )

            {

            iAvailableIaps->AddIap( iScannedWlanIaps->IapL( i ) );

            }

#endif      //__WINSCW__

        for( i = 0; i < iActiveIaps->Count(); i++ )

            {

            iAvailableIaps->AddIap( iActiveIaps->IapL( i ) );

            }

        TInt t=0;

		while( t < iService->iIapList->Count() )

			{

			TInt temp = iService->iIapList->IapL( t ).iId;

			RCmConnectionMethodExt conn;

			CleanupClosePushL( conn );

			TRAPD( err, conn = 

			    manager.ConnectionMethodL( iService->iIapList->IapL( t ).iId ) );

			    if( err == KErrNone )

			        {

			        if( KUidWlanBearerType != conn.GetIntAttributeL( CMManager::ECmBearerType ) )

			            {

			            CleanupStack::PopAndDestroy( &conn );

                    	CleanupStack::PopAndDestroy( &manager );

			            // Found read only iap other than wlan

			            SelectL( aGetUsedIapReq, iService->iIapList->IapL( t ).iId );

			            return;

			            }

			        }

			TInt s=0;

			while( s < iAvailableIaps->Count() )

		        {

				if( iService->iIapList->IapL( t ).iId == iAvailableIaps->IapL( s ).iId )

			        {

			        CleanupStack::PopAndDestroy( &conn );

			        CleanupStack::PopAndDestroy( &manager );

                    // Found suitable read only iap, select

                    SelectL( aGetUsedIapReq, iService->iIapList->IapL( t ).iId );

                    return;

					}

				s++;

				}

		    CleanupStack::PopAndDestroy( &conn );

		    t++;

			}

	    }

    //Check destination key

    if( destId == KIptvCenRepAPModeAlwaysAsk )