/*

* Copyright (c) 2009 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:  This class implements BgScan AWS communication.

*

*/

/*

*/

#include <e32base.h>

#include "awsinterface.h"

#include "awsenginebase.h"

#include "wlanbgscancommandlistener.h"

#include "wlanbgscancommand.h"

#include "wlanbgscanawscomms.h"

#include "wlanbgscan.h"

#include "am_debug.h"

/**

 * Maximum heap size for AWS thread.

 */

const TInt KMaxHeapSize     = 0x10000;

/**

 * BgScan version communicated to AWS.

 */

const TUint KBgScanVersion  = 1;

/**

 * Index of the first item in an array.

 */

const TInt KFirstItemIndex = 0;

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

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

// CWlanBgScanAwsComms::CWlanBgScanAwsComms

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

//

CWlanBgScanAwsComms::CWlanBgScanAwsComms( CWlanBgScan& aBgScan ) :

    CActive( CActive::EPriorityStandard ),

    iBgScan( aBgScan ),

    iAws( NULL ),

    iCommandHandler( NULL ),

    iAwsVersion( 0 ),

    iPendingCommand( EAwsCommandMax ),

    iAwsOk( EFalse )

    {

    DEBUG( "CWlanBgScanAwsComms::CWlanBgScanAwsComms()" );

    }

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

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

//

    {

    }

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

// CWlanBgScanAwsComms::NewL

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

//

CWlanBgScanAwsComms* CWlanBgScanAwsComms::NewL( CWlanBgScan& aBgScan )

    {

    DEBUG( "CWlanBgScanAwsComms::NewL()" );

    CWlanBgScanAwsComms* self = new ( ELeave ) CWlanBgScanAwsComms( aBgScan );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

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

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

//

    {

    }

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

// CWlanBgScanAwsComms::CleanupEComArray

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

//

void CWlanBgScanAwsComms::CleanupEComArray(TAny* aArray)

    {

    DEBUG( "CWlanBgScanAwsComms::CleanupEComArray()" );

    ASSERT( aArray );

    RImplInfoPtrArray *implInfoArray = static_cast<RImplInfoPtrArray*> ( aArray );

    implInfoArray->ResetAndDestroy();

    implInfoArray->Close();

    }

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

// CWlanBgScanAwsComms::StartAwsThreadL

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

//

void CWlanBgScanAwsComms::StartAwsThreadL()

    {

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL()" );

    RImplInfoPtrArray awsImplArray;

    TCleanupItem awsImplArrayCleanup( CleanupEComArray, &awsImplArray );

    CleanupStack::PushL( awsImplArrayCleanup );

    CAwsEngineBase::ListImplementationsL( awsImplArray );

    if( awsImplArray.Count() == 0 )

        {

        DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - no AWS implementation found" );

        User::Leave( KErrNotFound );

        }

    // first found AWS implementation will be taken into use

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - creating AWS thread" );

    RThread thread;

                                AwsThreadEntryPoint,

                                KDefaultStackSize,

                                KMinHeapSize,

                                KMaxHeapSize, 

                                reinterpret_cast<TAny*>( this ) );

    if( err != KErrNone)

        {

        DEBUG1( "CWlanBgScanAwsComms::StartAwsThreadL() - error: thread creation failed with error %i", err );

        User::Leave( err );

        }

    thread.Resume();

    thread.Close();

    DEBUG( "CWlanBgScanAwsComms::StartAwsThreadL() - done" );    

    }

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

// CWlanBgScanAwsComms::AwsThreadEntryPoint

//

// This method is executing in the context of the AWS thread.

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

//

TInt CWlanBgScanAwsComms::AwsThreadEntryPoint( TAny* aThisPtr )

    {

    CWlanBgScanAwsComms* self = static_cast<CWlanBgScanAwsComms*>( aThisPtr );

    // create cleanup stack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if ( cleanup == NULL )

        {

        DEBUG("CWlanBgScanAwsComms::AwsThreadEntryPoint() - error: Cleanup stack creation failed");

        User::Exit( KErrNoMemory );

        }

    __UHEAP_MARK;

    if ( err != KErrNone )

        {

        }

    __UHEAP_MARKEND;

    delete cleanup;

    cleanup = NULL;

    return KErrNone;    

    }

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

//

// This method is executing in the context of the AWS thread.

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

//

    {

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    CActiveScheduler::Start();

    // Thread execution will stay in CActiveScheduler::Start() until active scheduler is stopped

    // clean up

    CleanupStack::PopAndDestroy( scheduler );

    }

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

// From class MAwsBgScanProvider.

// CWlanBgScanAwsComms::SetInterval

//

// This method is executing in the context of the AWS thread.

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

//

void CWlanBgScanAwsComms::SetInterval( TUint32 aNewInterval, TRequestStatus& aStatus )

    {

    DEBUG1( "CWlanBgScanAwsComms::SetInterval() - new interval %u", aNewInterval );

    iCommandHandler->CommandQueue( CWlanBgScanCommand::ESetInterval, aNewInterval, aStatus );

    DEBUG( "CWlanBgScanAwsComms::SetInterval() - returning" );    

    }

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

// CWlanBgScanAwsComms::SendOrQueueAwsCommand

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

//

void CWlanBgScanAwsComms::SendOrQueueAwsCommand( TAwsMessage& aMessage )

    {

    DEBUG1( "CWlanBgScanAwsComms::SendOrQueueAwsCommand( command %u )", aMessage.iCmd );

    // if a request is pending, queue the new command

    if( iStatus.Int() == KRequestPending )

        {

        DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - request pending -> queue new command" );

        // store command to queue

        TInt err = iAwsMsgQueue.Append( aMessage );

        if( KErrNone == err )

            {

            DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - command queued successfully" );

            }

        else

            {

            DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - command queueing failed" );

            }

        return;

        }

    SendAwsCommand( aMessage );

    DEBUG( "CWlanBgScanAwsComms::SendOrQueueAwsCommand() - done" );

    }

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

// CWlanBgScanAwsComms::SendAwsCommand

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

//

void CWlanBgScanAwsComms::SendAwsCommand( TAwsMessage& aMessage )

    {

    DEBUG1( "CWlanBgScanAwsComms::SendAwsCommand( command %u )", aMessage.iCmd );

    if( !iAws )

        {

        DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - error: no AWS present!" );

        ASSERT( 0 );

        return;

        }

    DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - sending command" );

    switch( aMessage.iCmd )

        {

        case EStart:

            {

            iPendingCommand = EStart;

            iAws->Start( iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - EStart command sent" );

            break;

            }

        case EStop:

            {

            iPendingCommand = EStop;

            iAws->Stop( iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - EStop command sent" );

            break;

            }

        case ESetPowerSaveMode:

            {

            iPendingCommand = ESetPowerSaveMode;

            iAws->SetPowerSaveMode( static_cast<TAwsPsMode>( aMessage.iParameter ), iStatus );

            SetActive();

            DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - ESetPowerSaveMode command sent" );

            break;

            }

        default:

            {

            iPendingCommand = EAwsCommandMax;

            DEBUG1( "CWlanBgScanAwsComms::SendAwsCommand() - unknown command %u", aMessage.iCmd );

            ASSERT( 0 );

            }

        }

    DEBUG( "CWlanBgScanAwsComms::SendAwsCommand() - done" );

    }

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

// CWlanBgScanAwsComms::RunL

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

//

void CWlanBgScanAwsComms::RunL()

    {   

    DEBUG2( "CWlanBgScanAwsComms::RunL() - command: %u, completion status: %d", iPendingCommand, iStatus.Int() );

    TAwsMessage cmd = { EAwsCommandMax, NULL };

    // if there are more commands, send the next one

    if( iAwsMsgQueue.Count() )

        {

        cmd = static_cast<TAwsMessage> ( iAwsMsgQueue[KFirstItemIndex] );

        iAwsMsgQueue.Remove( KFirstItemIndex );

        SendAwsCommand( cmd );

        }

    }

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

// CWlanBgScanAwsComms::DoCancel

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

//

void CWlanBgScanAwsComms::DoCancel()

    {

    DEBUG( "CWlanBgScanAwsComms::DoCancel()" );

    }

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

// CWlanBgScanAwsComms::RunError

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

//

TInt CWlanBgScanAwsComms::RunError( TInt aError )

    {

    DEBUG1( "CWlanBgScanAwsComms::RunError( %d )", aError );

    return aError;

    }

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

// CWlanBgScanAwsComms::DoSetInterval

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

//

void CWlanBgScanAwsComms::DoSetInterval( TUint32 aNewInterval )

    {

    DEBUG1( "CWlanBgScanAwsComms::DoSetInterval( aNewInterval: %u )", aNewInterval );

    iBgScan.DoSetInterval( aNewInterval );

    }