/*

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

*

*/

//  EXTERNAL INCLUDES

#include <eikenv.h>

#include <apgcli.h>

#include <apgtask.h>

#include <ictsclientinterface.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmpluginwlandef.h>

#include <centralrepository.h>

#include <internetconnectivitycrkeys.h>

#include <featmgr.h>

#include <sysutil.h>

#include <wlanerrorcodes.h>

//  CLASS HEADER

#include "wsfmodel.h"

//  INTERNAL INCLUDES

#include "wsfwlaninfoarray.h"

#include "wsfwlaniapwizard.h"

#include "wsfapplauncher.h"

#include "wsfmodelobserver.h"

#include "wsfstatechangeobserver.h"

#include "wsfscreensaverwatcher.h"

#include "wsflogger.h"

using namespace CMManager;

/**

* UID of helper application 

* used when model is instantiated in the active idle

*/

static const TUid KHelperApUid = { 0x10281CEB };

/**

* Estimated overhead for access point creation 

*/

const TInt KEstimatedOverhead = 8192;

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

// CWsfModel::NewL

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

//

EXPORT_C CWsfModel* CWsfModel::NewL( MWsfStateChangeObserver& aObserver,

                                     const TBool aScreenSaverAware )

    {

    CWsfModel* self = CWsfModel::NewLC( aObserver, aScreenSaverAware );

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfModel::NewLC

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

//

EXPORT_C CWsfModel* CWsfModel::NewLC( MWsfStateChangeObserver& aObserver,

                                      const TBool aScreenSaverAware )

    {

    CWsfModel* self = new( ELeave ) CWsfModel;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver, aScreenSaverAware );

    return self;

    }

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

// CWsfModel::~CWsfModel

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

//

EXPORT_C CWsfModel::~CWsfModel()

    {

    LOG_ENTERFN( "CWsfModel::~CWsfModel" );

    iSession.CancelNotifyEvent();

    iSession.Close();

    delete iScreenSaverWatcher;

    delete iArray;   

    delete iObservedWlan;

    delete iBrowserLauncher;

    }

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

// CWsfModel::CWsfModel

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

//

CWsfModel::CWsfModel(): 

    iEikEnv( CEikonEnv::Static() ),

    iRefreshing( EFalse )

    {

    }

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

// CWsfModel::ConstructL

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

//

void CWsfModel::ConstructL( MWsfStateChangeObserver& aObserver, 

                            const TBool aScreenSaverAware )

    {

    iArray = CWsfWlanInfoArray::NewL(); 

    iBrowserLauncher = CWsfAppLauncher::NewL();

    User::LeaveIfError( iSession.Connect() ); 

    iSession.NotifyEventL( aObserver );

    if ( aScreenSaverAware )

        {

        iScreenSaverWatcher = CWsfScreenSaverWatcher::NewL( *this );

        }

    }

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

// CWsfModel::SetEngineObserver

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

//

EXPORT_C void CWsfModel::SetEngineObserver( MWsfModelObserver* aObserver )

    {

    LOG_ENTERFN( "CWsfModel::SetEngineObserver" );

    iObserver = aObserver;

    }

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

// CWsfModel::GetWlanListL

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

//

EXPORT_C CWsfWlanInfoArray* CWsfModel::GetWlanListL()

    {

    LOG_ENTERFN( "CWsfModel::GetWlanListL" );

    iArray->Reset();

    iSession.UpdateWlanListL( iArray );

    return iArray;

    }

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

// CWsfModel::GetWlanListSize

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

//

EXPORT_C void CWsfModel::GetWlanListSize( TPckgBuf<TUint>& aPckg, 

                                           TRequestStatus& aStatus )

    {

    LOG_ENTERFN( "CWsfModel::GetWlanListSize" );

    iSession.GetWlanListSize( aPckg, aStatus );

    }

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

// CWsfModel::GetWlanList

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

//

EXPORT_C void CWsfModel::GetWlanList( TPckgBuf<TUint>& aPckg, TPtr8& aPtr, 

                                       TRequestStatus& aStatus )

    {

    LOG_ENTERFN( "CWsfModel::GetWlanList" );

    iSession.GetWlanList( aPckg, aPtr, aStatus );

    }

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

// CWsfModel::SetActiveViewL

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

//

EXPORT_C void CWsfModel::SetActiveViewL( TInt aViewId )

    {

    TUid id;

    id.iUid = aViewId;

    iActiveView = id;

    }

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

// CWsfModel::ActiveViewL

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

//

EXPORT_C TUid CWsfModel::ActiveViewL()

    {

    return iActiveView;

    }

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

// CWsfModel::SetObservedWlanL

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

//

EXPORT_C void CWsfModel::SetObservedWlanL( const TDesC8& aSsid )

    {

    HBufC8* ssid = aSsid.AllocL();

    delete iObservedWlan;

    iObservedWlan = ssid;

    }

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

// CWsfModel::ObservedWlan

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

//

EXPORT_C const TDesC8& CWsfModel::ObservedWlan()

    {

    return *iObservedWlan;

    }

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

// CWsfModel::ConnectL

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

//

EXPORT_C int CWsfModel::ConnectL( TUint32 aIapId, TBool aConnectOnly,

                                  TWsfIapPersistence aPersistence )

    {

    LOG_ENTERFN( "CWsfModel::ConnectL" );

    if ( iObserver )

        {

        iObserver->ConnectingL( aIapId );

        }

    TInt err = iSession.ConnectWlanBearerL( aIapId, aConnectOnly, aPersistence );

    if ( err == KErrNone )

        {

        iConnectedIapId = aIapId;

        }

    else

        {

        if ( iObserver )

            {

            iObserver->BrowserLaunchFailed( err );            

            }

        }

    if ( iObserver )

        {

        iObserver->ConnectingFinishedL( err );

        }

    iRefreshing = iSession.RequestScanL();

    return err;

    }

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

// CWsfModel::ConnectL

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

//

EXPORT_C void CWsfModel::ConnectL( TPckgBuf<TBool>& aPckg, TUint32 aIapId,

                                   TBool aConnectOnly,

                                   TWsfIapPersistence aPersistence,

                                   TRequestStatus& aStatus )

    {

    LOG_ENTERFN( "CWsfModel::ConnectL" );

    if ( iObserver )

        {

        iObserver->ConnectingL( aIapId );

        }

    iSession.ConnectWlanBearer( aPckg, aIapId, aConnectOnly, aPersistence, aStatus );

    }

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

// CWsfModel::SetConnectResultL

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

//

EXPORT_C void CWsfModel::SetConnectResultL( TInt aResult, TUint /*aIapId*/ )

    {

    LOG_ENTERFN( "CWsfModel::SetConnectResultL" );

    iSession.SetConnectWlanBearerResult( aResult );

    if ( iObserver && aResult != KErrNone )

        {

        iObserver->ConnectingFinishedL( aResult );

        }

    }

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

// CWsfModel::DisconnectL

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

//

EXPORT_C void CWsfModel::DisconnectL()

    {

    LOG_ENTERFN( "CWsfModel::DisconnectL" );

    TBool disconnected = iSession.DisconnectWlanBearerL();

    LOG_WRITEF( "disconnected = %d", disconnected );

    iConnectedIapId = 0;

    if ( !disconnected )

        {

        iRefreshing = iSession.RequestScanL(); 

        }

    }

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

// CWsfModel::Disconnect

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

//

EXPORT_C void CWsfModel::Disconnect( TPckgBuf<TBool>& aPckg, TRequestStatus& aStatus )

    {

    LOG_ENTERFN( "CWsfModel::Disconnect" );

    iSession.DisconnectWlanBearer( aPckg, aStatus );

    iConnectedIapId = 0;

    }

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

// CWsfModel::Refreshing

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

//

EXPORT_C TBool CWsfModel::Refreshing()

    {

    return iRefreshing;

    }

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

// CWsfModel::SetRefreshState

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

//

EXPORT_C void CWsfModel::SetRefreshState( TBool aRefreshing )

    {

    iRefreshing = aRefreshing;

    }

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

// CWsfModel::EnableScanL

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

//

EXPORT_C TBool CWsfModel::EnableScanL()

    {

    LOG_ENTERFN( "CWsfModel::EnableScanL" );

    TBool enableScan( iSession.EnableScanL() );

    if ( iScreenSaverWatcher )

        {

        iScreenSaverWatcher->Cancel();

        iScreenSaverWatcher->StartStatusScanning();

        }

    return enableScan;

    }

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

// CWsfModel::DisableScanL

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

//

EXPORT_C TBool CWsfModel::DisableScanL()

    {

    LOG_ENTERFN( "CWsfModel::DisableScanL" );

    TBool disableScan( iSession.DisableScanL() );   

    if ( iScreenSaverWatcher )

        {

        iScreenSaverWatcher->Cancel();

        }

    return disableScan; 

    }

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

// CWsfModel::IsScanEnabledL

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

//

EXPORT_C TBool CWsfModel::IsScanEnabledL()

    {

    return iSession.IsScanEnabledL(); 

    }

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

// CWsfModel::LaunchBrowserL

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

//

EXPORT_C void CWsfModel::LaunchBrowserL( TUint32 aIapId )

    {

    LOG_ENTERFN( "CWsfModel::LaunchBrowserL" );

    if ( !iBrowserLauncher->Launching() ||

         iBrowserLauncher->BrowserIap() != aIapId ) 

        {

        LOG_WRITE( "launching browser..." );

        iConnectedIapId = aIapId;        

        iBrowserLauncher->LaunchBrowserL( *this, aIapId );

        }

    else if ( iBrowserLauncher->BrowserIap() == aIapId ) 

        {

        LOG_WRITE( "bringing browser to foreground..." );

        ContinueBrowsingL();

        }

    }

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

// CWsfModel::ContinueBrowsingL

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

//

EXPORT_C void CWsfModel::ContinueBrowsingL()

    {

    LOG_ENTERFN( "CWsfModel::ContinueBrowsingL(void)" );

    iBrowserLauncher->ContinueBrowsingL();

    }

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

// CWsfModel::ContinueBrowsingL

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

//

EXPORT_C void CWsfModel::ContinueBrowsingL( TUint32 aIapId )

    {

    LOG_ENTERFN( "CWsfModel::ContinueBrowsingL(TUint32)" );

    iBrowserLauncher->ContinueBrowsingL( *this, aIapId );

    }    

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

// CWsfModel::CreateAccessPointL

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

//

EXPORT_C TBool CWsfModel::CreateAccessPointL( TWsfWlanInfo& aWlan, 

                                              TBool aExplicitDefine )

    {

    LOG_ENTERFN( "CWsfModel::CreateAccessPointL" );

    if ( aExplicitDefine )

        {

        LOG_WRITE( "called from 'Define access point'" );

        }

    CheckSpaceBelowCriticalLevelL();

    CheckUnknownWapiL( aWlan );

    CWsfWlanIapWizard* iapWizard = CWsfWlanIapWizard::NewLC();

    // the wlaninfo must be persistent to avoid nullpointer crashes due to

    // background refreshing 

    TBool ret( ETrue );

    // query necessary data

    if ( !iapWizard->LaunchWizardL( aWlan, aExplicitDefine ) )

        {

        LOG_WRITE( "iapWizard.LaunchWizardL failed" );

        ret = EFalse;

        }

    // then create accesspoint

    if ( ret )

        {

        if ( iapWizard->CreateAccessPointL() )

            {

            // copy back the IAP id

            LOG_WRITEF( "IAP id = %d", aWlan.iIapId );

            }

        else

            {

            LOG_WRITE( "iapWizard.CreateAccessPointL failed" );

            ret = EFalse;

            }

        }

    CleanupStack::PopAndDestroy( iapWizard );

    return ret;

    }

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

// CWsfModel::RefreshScanL

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

//

EXPORT_C TBool CWsfModel::RefreshScanL()

    {

    LOG_ENTERFN( "CWsfModel::RefreshScanL" );

    iRefreshing = iSession.RequestScanL();

    LOG_WRITEF( "iRefreshing = %d", iRefreshing );

    return iRefreshing;

    }

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

// CWsfModel::RefreshScan

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

//

EXPORT_C void CWsfModel::RefreshScan( TPckgBuf<TBool>& aPckg, 

                                       TRequestStatus& aStatus )

    {

    LOG_ENTERFN( "CWsfModel::RefreshScan" );

    iSession.RequestScan( aPckg, aStatus );

    }

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

// CWsfModel::CloseHelperApplication

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

//

EXPORT_C TBool CWsfModel::CloseHelperApplication()

    {

    LOG_ENTERFN( "CWsfModel::CloseHelperApplication" );

    TBool endTaskCalled = EFalse;

    // check if the app is already running ... and kill it.

    TUid id( TUid::Uid( KHelperApUid.iUid ) );

    TApaTaskList taskList( iEikEnv->WsSession() );

    TApaTask task = taskList.FindApp( id );

    if ( task.Exists() )

        {

        LOG_WRITE( "ending task" );

        task.EndTask();

        endTaskCalled = ETrue;

        }