/*

* Copyright (c) 2008-2009 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:    wrapper for Back Stepping Service

*

*/

// from AIW and LIW

#include <liwcommon.h>

#include <liwservicehandler.h>

#include <glxtracer.h>

#include <glxlog.h>

// parameter names used by BS Service

#include "glxbsserviceconstants.h"

// for CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "glxbackservicewrapper.h"

using namespace LIW;

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

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

// 

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

//

CGlxBackServiceWrapper::CGlxBackServiceWrapper()

    {

    }

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

// 

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

//

void CGlxBackServiceWrapper::ConstructL( const TUid aUid )

    {

    TRACER( "CGlxBackServiceWrapper::ConstructL" );

    // create Service Handler and keep as long as access to BS Service needed

    iServiceHandler = CLiwServiceHandler::NewL();

    // for convinience keep pointers to Service Handler param lists

	iInParamList = &iServiceHandler->InParamListL();

	iOutParamList = &iServiceHandler->OutParamListL();

    RCriteriaArray criteriaArray;

	CleanupResetAndDestroyPushL( criteriaArray );

	// create Liw criteria

	CLiwCriteriaItem* criterion = 

	                CLiwCriteriaItem::NewLC( KLiwCmdAsStr, KBSInterface, KBSServiceID );

	criterion->SetServiceClass( TUid::Uid( KLiwClassBase ) );

	criteriaArray.AppendL( criterion );

	CleanupStack::Pop( criterion );

    // attach Liw criteria

	iServiceHandler->AttachL( criteriaArray );

	// get BS Service interface

	iServiceHandler->ExecuteServiceCmdL( *criterion, 

	                                        *iInParamList, 

	                                        *iOutParamList );

	CleanupStack::PopAndDestroy( &criteriaArray );

	// extract BS interface from output params

	TInt pos( 0 );

	iOutParamList->FindFirst( pos, KBSInterface );

	if( pos != KErrNotFound )

		{

		iBSInterface = (*iOutParamList)[pos].Value().AsInterface();	

		}

    if ( !iBSInterface )

        {

        // handle no BS Service

        User::Leave( KErrNotFound );

        }

    InitializeL( aUid );

    }

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

// 

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

//

EXPORT_C CGlxBackServiceWrapper* CGlxBackServiceWrapper::NewL( 

                                                            const TUid aUid )

    {

    TRACER( "CGlxBackServiceWrapper::NewL" );

    CGlxBackServiceWrapper* self = 

                        CGlxBackServiceWrapper::NewLC( aUid );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

EXPORT_C CGlxBackServiceWrapper* CGlxBackServiceWrapper::NewLC( 

                                                            const TUid aUid )

    {

    TRACER( "CGlxBackServiceWrapper::NewLC" );

    CGlxBackServiceWrapper* self = new( ELeave ) CGlxBackServiceWrapper;

    CleanupStack::PushL( self );

    self->ConstructL( aUid );

    return self;

    }

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

// 

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

//

CGlxBackServiceWrapper::~CGlxBackServiceWrapper()

    {

    TRACER( "CGlxBackServiceWrapper::~CGlxBackServiceWrapper" );

    if ( iBSInterface )

        {

        iBSInterface->Close();

        }

    delete iServiceHandler;

    }

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

// 

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

//

EXPORT_C TInt CGlxBackServiceWrapper::ForwardActivationEventL( const TDesC8& aState, 

                                                        const TBool aEnter )

    {

    TRACER( "CGlxBackServiceWrapper::ForwardActivationEventL" );

    iInParamList->Reset();

	iOutParamList->Reset();

	TLiwGenericParam state( KBSInParamState, TLiwVariant( aState ) );

	iInParamList->AppendL( state );

	TLiwGenericParam enter( KBSInParamEnter, TLiwVariant( aEnter ) );

	iInParamList->AppendL( enter );

	iBSInterface->ExecuteCmdL( KBSCmdForwardActivationEvent, 

	                            *iInParamList, 

	                            *iOutParamList );

    TInt result = HandleResultL();

	iInParamList->Reset();

	iOutParamList->Reset();

	return result;

    }

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

// 

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

//

EXPORT_C TInt CGlxBackServiceWrapper::HandleBackCommandL( const TDesC8& aState, 

                                                   const TBool aCheckOnly)

    {

    TRACER( "CGlxBackServiceWrapper::HandleBackCommandL" );

    iInParamList->Reset();

	iOutParamList->Reset();

	TLiwGenericParam state( KBSInParamState, TLiwVariant( aState ) );

	iInParamList->AppendL( state );

	TLiwGenericParam checkOnly( KBSInParamCheckOnly, TLiwVariant( aCheckOnly ) );

	iInParamList->AppendL( checkOnly );

	iBSInterface->ExecuteCmdL( KBSCmdHandleBackCommand, 

	                            *iInParamList, 

	                            *iOutParamList );

	TInt result = HandleResultL();

	iInParamList->Reset();

	iOutParamList->Reset();

	return result;

    }

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

// 

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

//

void CGlxBackServiceWrapper::InitializeL( const TUid aUid )

    {

    TRACER( "CGlxBackServiceWrapper::InitializeL" );

    iInParamList->Reset();

	iOutParamList->Reset();

	TLiwGenericParam appUid( KBSInParamAppUid, TLiwVariant( aUid.iUid ) );

	iInParamList->AppendL( appUid );

	iBSInterface->ExecuteCmdL( KBSCmdInitialize, 

	                            *iInParamList, 

	                            *iOutParamList );

    if ( HandleResultL() != 1 )

        {

        // Initialize command was not consumed - handle failiure

        User::Leave( KErrArgument );

        }

	iInParamList->Reset();

	iOutParamList->Reset();

    }

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

// 

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

//

TInt CGlxBackServiceWrapper::HandleResultL()

    {

    TRACER( "CGlxBackServiceWrapper::HandleResultL" );

    TInt statusInfo( KErrNotFound );

    TInt posErr( 0 );

	iOutParamList->FindFirst( posErr, EGenericParamError );

	if( posErr != KErrNotFound )

		{

		// error code found - extract and handle

		TInt errorCode( KErrNone );

		(*iOutParamList)[posErr].Value().Get( errorCode );

		User::LeaveIfError( errorCode );

		}

    // if no error returned, carry on

    TInt posStat( 0 );

    iOutParamList->FindFirst( posStat, KBSOutParamStatusInfo );

    if( posStat != KErrNotFound )

		{

		// status info present - extract and return

		(*iOutParamList)[posStat].Value().Get( statusInfo );

		}

	else

	    {

	    // no return value

	    // this should not happen

	    User::Leave( KErrNotFound );

	    }

    return statusInfo;

    }