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


//  EXTERNAL INCLUDES
#include <d32dbms.h> 
#include <WlanCdbCols.h>
#include <wlancontainer.h>

#include <centralrepository.h>
#include <wlandevicesettingsinternalcrkeys.h>
#include <featmgr.h>

//  CLASS HEADER
#include "wsfwlansettingsaccessor.h"

// INTERNAL INCLUDES
#include "wsfwlanscanintervalchangeobserver.h"
#include "wsflogger.h"


using namespace CommsDat;

// background scan disabled value
static const TUint KWlanBgScanIntervalNever = 0;

// background scan automatic scanning value
static const TUint KWlanBgScanIntervalAuto = 0xffffffff;

// default background scan interval in seconds
static const TUint KWlanBgScanIntervalDefault = 300;

// hold-up time after first DB notification to prevent bursts (in microseconds)
static const TUint KDbNotificationHoldupTime = 1000 * 1000;



// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::NewL
// ----------------------------------------------------------------------------
//
CWsfWlanSettingsAccessor* CWsfWlanSettingsAccessor::NewL( 
                                                     CMDBSession& aDbSession )
    {
    CWsfWlanSettingsAccessor *thisPtr = NewLC( aDbSession );
    CleanupStack::Pop( thisPtr );
    return thisPtr;
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::NewLC
// ----------------------------------------------------------------------------
//
CWsfWlanSettingsAccessor* CWsfWlanSettingsAccessor::NewLC( 
                                                     CMDBSession& aDbSession )
    {
    CWsfWlanSettingsAccessor *thisPtr = 
                          new (ELeave) CWsfWlanSettingsAccessor( aDbSession );
    CleanupStack::PushL( thisPtr );
    thisPtr->ConstructL();
    return thisPtr; 
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::CWsfWlanSettingsAccessor
// ----------------------------------------------------------------------------
//
CWsfWlanSettingsAccessor::CWsfWlanSettingsAccessor( CMDBSession& aDbSession ): 
    CActive( CActive::EPriorityStandard ), 
    iDbSession( &aDbSession ),
    iBeingHeldUp( EFalse )
    {
    }

    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::ConstructL
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::ConstructL()
    {
    CActiveScheduler::Add( this );
    
    // get WLAN table id
    TRAP_IGNORE( iTableId = CCDWlanDeviceSettingsRecord::TableIdL( 
                                                              *iDbSession ) );

    if ( !iTableId )
        {
        iTableId = CCDWlanDeviceSettingsRecord::CreateTableL( *iDbSession );
        }

    iWlanSettingsRecord = new (ELeave) CCDWlanDeviceSettingsRecord( iTableId );
    iWlanSettingsRecord->iWlanDeviceSettingsType = KWlanUserSettings;
    
    if ( !iWlanSettingsRecord->FindL( *iDbSession ) )
        {
        User::Leave( KErrNotFound );
        }
    
    User::LeaveIfError( iTimer.CreateLocal() );
    
    DoCheckSettingL( iScanInterval, iShowAvailability );
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::~CWsfWlanSettingsAccessor
// ----------------------------------------------------------------------------
//
CWsfWlanSettingsAccessor::~CWsfWlanSettingsAccessor()
    {
    Cancel();
    iTimer.Close();
    iDbSession = NULL; // not owning
    iChangeObserver = NULL; // not owning 
    delete iWlanSettingsRecord; // own
    iWlanSettingsRecord = NULL;
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::ScanInterval
// ----------------------------------------------------------------------------
//
TUint CWsfWlanSettingsAccessor::ScanInterval() const
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::ScanInterval" );
    return iScanInterval;
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::ShowAvailability
// ----------------------------------------------------------------------------
//
TBool CWsfWlanSettingsAccessor::ShowAvailability() const
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::ShowAvailability" );
    return iShowAvailability;
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::RequestNotificationL
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::RequestNotificationL( 
                                MWsfWlanScanIntervalChangeObserver& aObserver )
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::RequestNotificationL" );
    iChangeObserver = &aObserver;
    IssueNotificationRequestL();
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::IssueNotificationRequestL
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::IssueNotificationRequestL()
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::IssueNotificationRequestL" );
    if ( iChangeObserver )
        {
        if ( !IsActive() )
            {
            LOG_WRITE( "issuing..." );
            User::LeaveIfError( iWlanSettingsRecord->RequestNotification( 
                                                     *iDbSession, iStatus ) );
            SetActive();    
            }
        }
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::CancelNotifications
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::CancelNotifications()
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::CancelNotifications" );
    Cancel();
    iChangeObserver = NULL;
    }


// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::DoCheckSettingL
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::DoCheckSettingL( TUint& aBgScanInterval, 
                                                TBool& aShowAvailability )
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::DoCheckSettingL" );
    // open the wlan settings table
    
    iWlanSettingsRecord->RefreshL( *iDbSession );
    FeatureManager::InitializeLibL();
    
    aShowAvailability = ( iWlanSettingsRecord->iBgScanInterval != 
                                                    KWlanBgScanIntervalNever );

    // read the common value
    if ( iWlanSettingsRecord->iBgScanInterval == KWlanBgScanIntervalNever )
        {
        if ( iWlanSettingsRecord->iSavedBgScanInterval == 
                                                     KWlanBgScanIntervalNever )
            {
            TInt defaultScanInterval( KWlanBgScanIntervalDefault );

							if (FeatureManager::FeatureSupported( KFeatureIdPowerSave ))
							{
         	   // Read the default value from CenRep (different in PSM mode)
          	  CRepository* cenrep = CRepository::NewL( 
                                      KCRUidWlanDeviceSettingsRegistryId );
          	  cenrep->Get( KWlanDefaultBGScanInterval, defaultScanInterval );
         		  delete cenrep;
         			 } 

            aBgScanInterval = TUint( defaultScanInterval );
            }
        else
            {
            aBgScanInterval = iWlanSettingsRecord->iSavedBgScanInterval;
            }
        }   
    else
        {
        aBgScanInterval = iWlanSettingsRecord->iBgScanInterval;
        }
    
    // Set scan interval to default value if adaptive scanning value is
    // found from db
    if (aBgScanInterval == KWlanBgScanIntervalAuto )
        {
        TInt defaultScanInterval( KWlanBgScanIntervalDefault );
        aBgScanInterval = TUint( defaultScanInterval );
        }
    
  	FeatureManager::UnInitializeLib();  
    LOG_WRITEF( "current bgScanInterval = %d sec", aBgScanInterval );
    LOG_WRITEF( "current showAvailability = %d", aShowAvailability );
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::CheckIfSettingChangedL
// ----------------------------------------------------------------------------
//
TBool CWsfWlanSettingsAccessor::CheckIfSettingChangedL()
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::CheckIfSettingChangedL" );
    LOG_WRITEF( "previous bgScanInterval = %d", iScanInterval );
    LOG_WRITEF( "previous showAvailability = %d", iShowAvailability );
    TUint newBgsi( 0 );
    TBool newSaf( EFalse );
    
    DoCheckSettingL( newBgsi, newSaf );
    
    TBool retval( newBgsi != iScanInterval || newSaf != iShowAvailability );
    iScanInterval = newBgsi;
    iShowAvailability = newSaf;
    
    return retval;    
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::RunL
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::RunL()
    {
    LOG_ENTERFN( "CWsfWlanSettingsAccessor::RunL" );
    LOG_WRITEF( "iStatus.Int() = %d", iStatus.Int() );

    // Symbian DB notifiers are triggered by everything that may happen in 
    // commsdat, so it would be very resource-consuming to check the value on 
    // each database event
    // Workaround: 1-sec delay when first callback is received

    if ( !iBeingHeldUp )
        {
        LOG_WRITE( "starting anti-burst delay" );
        iBeingHeldUp = ETrue;
        iTimer.After( iStatus, TTimeIntervalMicroSeconds32( 
                                                 KDbNotificationHoldupTime ) );
        SetActive();
        }
    else
        {
        LOG_WRITE( "checking changes" );
        iBeingHeldUp = EFalse;
        if ( CheckIfSettingChangedL() )
            {
            LOG_WRITE( "setting changed, notifying observer" );
            iChangeObserver->WlanScanIntervalChangedL( iScanInterval, 
                                                       iShowAvailability );
            }
            
        IssueNotificationRequestL();
        }

    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::DoCancel
// ----------------------------------------------------------------------------
//
void CWsfWlanSettingsAccessor::DoCancel()
    {
    iTimer.Cancel();
    iBeingHeldUp = EFalse;
    
    if ( iWlanSettingsRecord )
        {
        iWlanSettingsRecord->CancelNotification( *iDbSession, iStatus );
        }
    }
    
    
// ----------------------------------------------------------------------------
// CWsfWlanSettingsAccessor::RunError
// ----------------------------------------------------------------------------
//
TInt CWsfWlanSettingsAccessor::RunError( TInt /*aError*/ )
    {
    TRAP_IGNORE( IssueNotificationRequestL() );
    return KErrNone;
    }