/*
* Copyright (c) 2005 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 CActiveSelectWLanDlgPlugin.
*
*/


// INCLUDE FILES
#include <AknWaitDialog.h>
#include <ConnUiUtilsNotif.rsg>
#include <AknGlobalNote.h>
#include <StringLoader.h>
#include <centralrepository.h>
#include <AknSgcc.h>
#include <AknCapServerClient.h>
//#include <aknnotewrappers.h>

#include "ActiveSelectWLanDlgPlugin.h"
#include "SelectWLANDlg.h"
#include "ConnectionDialogsLogger.h"
#include "ConnectionUiUtilitiesPrivateCRKeys.h"


// CONSTANTS

/**
* For iPeriodic Timer, 10 seconds
* The interval between refreshing available wlan networks.
*/
LOCAL_D const TInt KTickDefaultInterval = 10000000;

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

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin* CActiveSelectWLanDlgPlugin::NewL()
// ---------------------------------------------------------
//
CActiveSelectWLanDlgPlugin* CActiveSelectWLanDlgPlugin::NewL( 
                                              CSelectWLanDlgPlugin* aPlugin )
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::NewL " );  
    
    CActiveSelectWLanDlgPlugin* self = 
                         new ( ELeave ) CActiveSelectWLanDlgPlugin( aPlugin );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::NewL " );      

    return self;        
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::ConstructL()
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::ConstructL()
    {     
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::ConstructL " );
       
    CActiveScheduler::Add( this );            
    iWlanDataProv = CWlanNetworkDataProvider::NewL();
    iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
    
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::ConstructL " );
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::CActiveSelectWLanDlgPlugin()
// ---------------------------------------------------------
//
CActiveSelectWLanDlgPlugin::CActiveSelectWLanDlgPlugin( 
                                                CSelectWLanDlgPlugin* aPlugin )
: CActive( EPriorityStandard ), 
  iPlugin( aPlugin )
    {
    }
    
// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::~CActiveSelectWLanDlgPlugin()
// ---------------------------------------------------------
//    
CActiveSelectWLanDlgPlugin::~CActiveSelectWLanDlgPlugin()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::~CActiveSelectWLanDlgPlugin " );
    Cancel();

    StopTimer();
    DestroyWaitDialog();

    if ( iResultsListDialog  && !( iResultsListDialog->GetOkToExit() ) )
        {
        CLOG_WRITEF( _L( "OkToExit %b" ), iResultsListDialog->GetOkToExit() );
        delete iResultsListDialog;
        iResultsListDialog = NULL;
        }
    
    DestroyAsyncWaitTrigger();
        
    delete iWlanDataProv;
    iWlanDataProv = NULL;

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::~CActiveSelectWLanDlgPlugin " );
    }


// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::DoCancel()
// ---------------------------------------------------------
// 
void CActiveSelectWLanDlgPlugin::DoCancel()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::DoCancel " );

    CLOG_WRITE( "stopping timer" );
    StopTimer();

    CLOG_WRITE( "deleting results list dialog" );
    DestroyResultsListDialog();

    CLOG_WRITE( "deleting wait dialog" );
    DestroyWaitDialog();

    CLOG_WRITE( "deleting wlan data provider" );
    delete iWlanDataProv;
    iWlanDataProv = NULL;

    DestroyAsyncWaitTrigger();

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::DoCancel " );
    }
    
// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::StartTimerL
// ---------------------------------------------------------
//    
void CActiveSelectWLanDlgPlugin::StartTimerL( TInt aTickInterval )
    {    
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::StartTimerL " );  
    
    if( !iPeriodic )
        {
        iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard ); 
        }
        
    iPeriodic->Start( aTickInterval, aTickInterval, TCallBack( Tick, this ) );
    
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::StartTimerL " );
    }


// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::StopTimer
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::StopTimer()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::StopTimer " );  
    
    if( iPeriodic )
        {
        CLOG_WRITE( "iPeriodic" );
        iPeriodic->Cancel();
        CLOG_WRITE( "Cancel" );
        
        delete iPeriodic;
        CLOG_WRITE( "delete" );
        
        iPeriodic = NULL;
        }        
    
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::StopTimer " );
    }
    
// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::DoTick
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::DoTick()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::DoTick " );

    if ( IsActive() == EFalse )
        {
        CLOG_WRITE( "not active anymore - making another scan request..." );

        SetActive();

#ifdef __WINS__
        TRequestStatus* clientStatus = &iStatus;
        User::RequestComplete( clientStatus, KErrNone );
#else
        iWlanDataProv->RefreshScanInfo( iStatus );
#endif
        }
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::Tick
// ---------------------------------------------------------
//
TInt CActiveSelectWLanDlgPlugin::Tick( TAny* aObject )
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::Tick " );

    CActiveSelectWLanDlgPlugin* myself =
                        static_cast<CActiveSelectWLanDlgPlugin*>( aObject );
    myself->DoTick();

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::Tick " );

    return 1;
    }


// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::RunL()
// ---------------------------------------------------------
//     
void CActiveSelectWLanDlgPlugin::RunL()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::RunL " );  
    
    DestroyAsyncWaitTrigger();

    if ( iWaitDialog )
        {
        iWaitDialog->ProcessFinishedL();     
        delete iWaitDialog;
        iWaitDialog = NULL;    
        }
    
    CLOG_WRITEF( _L( "iStatus.Int() : %d" ), iStatus.Int() );
    
    if( iStatus == KErrNone )
        {             
        iWlanDataProv->OnTimerExpiredL();
        
        CNetworkInfoArray* *const networkArray = 
                                   iWlanDataProv->GetNetworkInfoArray();
         
        const TInt resultsCount = ( *networkArray )->MdcaCount();

        CLOG_WRITEF( _L( "resultsCount : %d" ),resultsCount );

        if ( resultsCount > 0 )
            {
            if( iResultsListDialog )
                {
                iResultsListDialog->RefreshDialogL();
                }
            else
                {
                iResultsListDialog = CSelectWLANDlg::NewL( iPlugin, 
                                                           networkArray );

                iResultsListDialog->ExecuteLD( R_SELECT_WLAN_LIST_QUERY );

                if( iRefreshInterval )
                    {
                    StartTimerL( iRefreshInterval );
                    }
                }
            }
        else
            {
            StopTimer();
            
            DestroyWaitDialog();
            DestroyResultsListDialog();

            HBufC* stringLabel = StringLoader::LoadLC( 
                                                    R_INFO_NO_NETWORKS_FOUND );
/*** Deadlock                                              
            CAknGlobalNote* globalNote = CAknGlobalNote::NewLC();
            globalNote->ShowNoteL( EAknGlobalInformationNote, *stringLabel );

            CleanupStack::PopAndDestroy( globalNote );
            CleanupStack::PopAndDestroy( stringLabel );
***/

//// 3.1 solution: prevent deadlock, does not work in 3.0 because of avkon 
            RAknUiServer* globalNote = CAknSgcClient::AknSrv();
            if ( globalNote->Handle() )
                {
                globalNote->ShowGlobalNoteL( *stringLabel, 
                                            EAknGlobalInformationNote );
                }
            CleanupStack::PopAndDestroy( stringLabel );

//// End of 3.1 solution

/*** 3.0 solution
            CAknInformationNote* myLocalGlobalNote = new ( ELeave ) 
                                                CAknInformationNote( EFalse );
            myLocalGlobalNote->ExecuteLD( *stringLabel );
            CleanupStack::PopAndDestroy( stringLabel );

*** End of 3.0 solution    ***/
            
            iPlugin->SetCancelledFlag( ETrue );
            iPlugin->CompleteL( KErrNotFound );            
            }
        }
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::RunL " );      
        
    }
    
// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::StartSearchWlanNetworkL()
// ---------------------------------------------------------
//    
void CActiveSelectWLanDlgPlugin::StartSearchWlanNetworkL()
    {    
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::StartSearchWlanNetworkL " );  

    SetActive();    

#ifdef __WINS__
    TRequestStatus* clientStatus = &iStatus;
    User::RequestComplete( clientStatus, KErrNone );
#else
    iWlanDataProv->RefreshScanInfo( iStatus );
#endif
 
    // Start wait dialog asynchronously with low priority.
    // The reason for this is that sometimes WLAN scan results
    // are already in the cache and returned fast.
    // When this happens there is no point in displaying wait note.
    iRefreshInterval = GetRefreshInterval();
    CLOG_WRITEF( _L( "interval : %d" ),  iRefreshInterval );

    if ( !iAsyncWaitTrigger )
        {
        TCallBack cb( StartWaitNoteL, this );
        iAsyncWaitTrigger = new( ELeave ) CAsyncCallBack( cb, CActive::EPriorityLow );
        }
    iAsyncWaitTrigger->CallBack();

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::StartSearchWlanNetworkL " );
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::GetRefreshInterval()
// ---------------------------------------------------------
//    
TInt CActiveSelectWLanDlgPlugin::GetRefreshInterval()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::GetRefreshInterval " );

    CRepository* repository = NULL;
    TInt err( KErrNone );

    TRAP( err, 
          repository = CRepository::NewL( KCRUidConnectionUiUtilities ) );
          
    TInt variant( 0 );  
    CLOG_WRITEF( _L( "err : %d" ), err );
      
    if ( err == KErrNone )
        {
        TInt retval = repository->Get( KConnectionUiUtilitiesScanInterval, 
                                       variant ); 
                                       
        CLOG_WRITEF( _L( "retval : %d" ), retval );
                                                                             
        if ( retval == KErrNotFound )
            {
            variant = KTickDefaultInterval;
            }
        }
     else
        {
        variant = KTickDefaultInterval;
        }

    delete repository;

    CLOG_WRITEF( _L( "variant : %d" ), variant );
    
    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::GetRefreshInterval " );
    
    return variant;            
    }


// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::DestroyWaitDialog()
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::DestroyWaitDialog()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::DestroyWaitDialog " );

    delete iWaitDialog;
    iWaitDialog = NULL;

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::DestroyWaitDialog " );
    }


// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::DestroyResultsListDialog()
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::DestroyResultsListDialog()
    {
    CLOG_ENTERFN( "CActiveSelectWLanDlgPlugin::DestroyResultsListDialog " );

    if ( iResultsListDialog  && !( iResultsListDialog->GetOkToExit() ) )
        {
        delete iResultsListDialog;
        iResultsListDialog = NULL;
        }

    CLOG_LEAVEFN( "CActiveSelectWLanDlgPlugin::DestroyResultsListDialog " );
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::DestroyAsyncWaitTrigger()
// ---------------------------------------------------------
//
void CActiveSelectWLanDlgPlugin::DestroyAsyncWaitTrigger()
    {
    if ( iAsyncWaitTrigger )
        {
        iAsyncWaitTrigger->Cancel();
        delete  iAsyncWaitTrigger;
        iAsyncWaitTrigger= NULL;
        }
    }

// ---------------------------------------------------------
// CActiveSelectWLanDlgPlugin::StartWaitNoteL()
// ---------------------------------------------------------
//
TInt CActiveSelectWLanDlgPlugin::StartWaitNoteL( TAny* aObject )
    {
    CActiveSelectWLanDlgPlugin* myself = 
            static_cast<CActiveSelectWLanDlgPlugin*>( aObject );
    
    myself->DestroyWaitDialog();
    
    myself->iWaitDialog = new( ELeave )CAknWaitDialog
                        ( REINTERPRET_CAST( CEikDialog**, &(myself->iWaitDialog) ), ETrue );
    myself->iWaitDialog->ExecuteLD( R_SEARCHING_WLAN_WAIT_NOTE );
        
    return 0;   
    }

// End of File