/*
 * 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 CWsfLaunchAiHelperActiveWrapper.
 *
 */


// INCLUDE FILES
#include "wsflogger.h"
#include "wsfmodel.h"
#include "wsfaicontroller.h"
#include "wsflaunchaihelperactivewrapper.h"

// Category UID of AiHelper property
static const TUid KWsfAiHelperCategoryUid = { 0x10281CEB };

// key numbers within the property 
static const TUint KWsfAiHelperExitCodeKey = 0;
static const TUint KWsfAiHelperIapIdKey = 1;

/**
* Delay that we wait for the aihelper to terminate
*/
static const TInt KTimerTickInterval = 1 * 1000 * 1000; 


// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::CWsfLaunchAiHelperActiveWrapper
// ----------------------------------------------------------------------------
//
CWsfLaunchAiHelperActiveWrapper::CWsfLaunchAiHelperActiveWrapper() :
    CActive( EPriorityStandard ) // Standard priority
    {
    }


// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::NewLC
// ----------------------------------------------------------------------------
//
CWsfLaunchAiHelperActiveWrapper* CWsfLaunchAiHelperActiveWrapper::NewLC( 
                              CWsfModel* aModel, TWsfAiController &aController )
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::NewLC" );
    CWsfLaunchAiHelperActiveWrapper* self =
            new (ELeave) CWsfLaunchAiHelperActiveWrapper();
    CleanupStack::PushL( self );
    self->ConstructL( aModel, aController );
    return self;
    }


// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::NewL
// ----------------------------------------------------------------------------
//
CWsfLaunchAiHelperActiveWrapper* CWsfLaunchAiHelperActiveWrapper::NewL( 
                            CWsfModel* aModel, TWsfAiController &aController )
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::NewL" );
    CWsfLaunchAiHelperActiveWrapper* self = 
            CWsfLaunchAiHelperActiveWrapper::NewLC( aModel, aController );
    CleanupStack::Pop(); // self;
    return self;
    }


// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::ConstructL
// ----------------------------------------------------------------------------
//
void CWsfLaunchAiHelperActiveWrapper::ConstructL( CWsfModel* aModel,
                                            TWsfAiController &aController )
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::ConstructL" );
    CActiveScheduler::Add( this ); // Add to scheduler
    iModel = aModel;
    iController = &aController;
    User::LeaveIfError( iTimer.CreateLocal() );
    User::LeaveIfError( iAiHelperAppExitCode.Attach( KWsfAiHelperCategoryUid, 
                                                    KWsfAiHelperExitCodeKey ) );
    
    User::LeaveIfError( iAiHelperAppIapId.Attach( KWsfAiHelperCategoryUid, 
                                                  KWsfAiHelperIapIdKey ) );
    }

// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::~CWsfLaunchAiHelperActiveWrapper
// ----------------------------------------------------------------------------
//
CWsfLaunchAiHelperActiveWrapper::~CWsfLaunchAiHelperActiveWrapper()
    {
    LOG_ENTERFN( 
               "CWsfLaunchAiHelperActiveWrapper::~CWsfWLANListActiveWrapper" );
    Cancel(); // Cancel any request, if outstanding
    // Delete instance variables if any
    iAiHelperAppExitCode.Close();
    iAiHelperAppIapId.Close();
    iTimer.Close();
    }

// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::DoCancel
// ----------------------------------------------------------------------------
//
void CWsfLaunchAiHelperActiveWrapper::DoCancel()
    {
    iAiHelperAppExitCode.Cancel();
    iAiHelperAppIapId.Cancel();
    iTimer.Cancel();
    iStoppingHelper = iModel->CloseHelperApplication();
    }

// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::Start
// ----------------------------------------------------------------------------
//
void CWsfLaunchAiHelperActiveWrapper::Start( TWsfWlanInfo& aInfo, 
                                             TBool aConnectOnly,
                                             TBool aTestAccessPoint )
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::Start" );
    iStoppingHelper = EFalse;
    Cancel(); // Cancel any request, just to be sure
    iState = EUninitialized;
    iUsedInfo = aInfo;
    iConnectOnly = aConnectOnly;
    iTestAccessPoint = aTestAccessPoint;
    
    if ( iStoppingHelper )
        {
        LOG_WRITE( "Helper was stopped - wait for a while" );
        iTimer.Cancel();
        iTimer.After( iStatus, KTimerTickInterval );
        }
    else
        {
        LOG_WRITE( "Helper was not alive" );
        TRequestStatus* status = &iStatus;
        User::RequestComplete(status, KErrNone);
        }
    SetActive();
    }

// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::RunL
// ----------------------------------------------------------------------------
//
void CWsfLaunchAiHelperActiveWrapper::RunL()
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::RunL" );
    if ( iStatus == KErrNone )
        {
        if ( iState == EUninitialized )
            {
            LOG_WRITE( "Start launching ai helper" );
            // register for notification
            iAiHelperAppExitCode.Subscribe( iStatus );
            iModel->LaunchHelperApplicationL( iUsedInfo );
            iState = EInitialized;
            SetActive(); // Tell scheduler a request is active
            }
        else if (iState == EInitialized)
            {
            TInt exitCode( KErrNone );
            iAiHelperAppExitCode.Get( exitCode );

            LOG_WRITEF( "AiHelper returned %d", exitCode );

            if ( exitCode == KErrNone )
                {
                TInt iapId(0);
                iAiHelperAppIapId.Get( iapId );
                iUsedInfo.iIapId = TUint32( iapId );
                LOG_WRITEF( "AiHelper iap id = %d", iapId );
                if ( iUsedInfo.iIapId )
                    {
                    LOG_WRITE( "Iap id exist - connect" );
                    iController->ConnectL( iUsedInfo, iConnectOnly, 
                                           iTestAccessPoint );
                    }
                else
                    {
                    LOG_WRITE( "No iap id from ai helper" );
                    }
                }
            else
                {
                User::Leave(exitCode);
                }
            }
        else
            {
            LOG_WRITEF( "iState = %d", iState );
            }
        }
    else
        {
        LOG_WRITEF( "CWsfLaunchAiHelperActiveWrapper iStatus = %d", 
                                                               iStatus.Int() );
        }
    }

// ----------------------------------------------------------------------------
// CWsfLaunchAiHelperActiveWrapper::RunError
// ----------------------------------------------------------------------------
//
#ifdef _DEBUG
TInt CWsfLaunchAiHelperActiveWrapper::RunError( TInt aError )
    {
    LOG_ENTERFN( "CWsfLaunchAiHelperActiveWrapper::RunError" );
    LOG_WRITEF( "aError = %d", aError );
#else
TInt CWsfLaunchAiHelperActiveWrapper::RunError( TInt /*aError*/ )
    {
#endif
    return KErrNone;
    }