// 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 "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: Test wrapper for RSsmStateManager
// 
// 
//

#include <test/datawrapper.h>
#include <ssm/ssmstates.hrh>
#include <ssm/ssmsubstates.hrh>

#include "t_ssmstatemanager.h"

_LIT(KMainState,      "mainState");
_LIT(KSubState,       "subState");
_LIT(KReason,         "reason");  
_LIT(KAsync,          "async");

//commands
_LIT(KCmdNewL,                       "NewL");
_LIT(KCmdConnect,                    "Connect");
_LIT(KCmdClose,                      "Close");
_LIT(KCmdRequestStateTransition,     "RequestStateTransition");
_LIT(KCmdRequestStateTransitionCancel,  "RequestStateTransitionCancel");
_LIT(KCmdDestructor,                 "~");

/**
 * Two phase constructor
 */
CTestRSsmStateManager* CTestRSsmStateManager::NewL()
    {
    CTestRSsmStateManager*  testSsmStateManager = new (ELeave) CTestRSsmStateManager();
    CleanupStack::PushL(testSsmStateManager);
    testSsmStateManager->ConstructL();
    CleanupStack::Pop(testSsmStateManager);
    return testSsmStateManager; 
    }

/**
 * GetObject
 */
TAny*  CTestRSsmStateManager::GetObject()
    {
    return iSsmStateManager;
    }

/**
 * SetObjectL
 */
void CTestRSsmStateManager::SetObjectL(TAny* aAny)
    {
    DoCleanup();
    iSsmStateManager=static_cast<RSsmStateManager*> (aAny);
    }

/**
 * DisownObjectL
 */
void CTestRSsmStateManager::DisownObjectL()
    {
    iSsmStateManager = NULL;
    }

/**
 * Protected constructor. First phase construction
 */
CTestRSsmStateManager::CTestRSsmStateManager()
:CDataWrapper()
    {
    }

/**
 * Protected constructor. Second phase construction
 */
void CTestRSsmStateManager::ConstructL()
    {
    iActiveNotifyOnChange = CActiveCallback::NewL(*this);
    }

/**
 * Destructor.
 */
CTestRSsmStateManager::~CTestRSsmStateManager()
    {
    DoCleanup();
    delete iActiveNotifyOnChange;
    }

/**
 * Process a command read from the ini file
 *
 * @param aCommand  the command to process
 * @param aSection      the entry in the ini file requiring the command to be processed
 *
 * @return ETrue if the command is processed
 */
TBool CTestRSsmStateManager::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)
    {
    TBool retVal = ETrue;
    if (aCommand == KCmdNewL)
        {
        DoCmdNew();
        }
    else if (aCommand == KCmdConnect)
        {
        DoCmdConnect();
        }
    else if (aCommand == KCmdRequestStateTransition )
        {
        DoCmdRequestStateTransition(aSection, aAsyncErrorIndex);
        }  
    else if (aCommand == KCmdRequestStateTransitionCancel )
        {
        DoCmdRequestStateTransitionCancel();
        }
    else if (aCommand == KCmdClose)
        {
        DoCmdClose();
        }
    else if (aCommand == KCmdDestructor)
        {
        DoCmdDestructor();
        } 
    else
        {
        retVal = EFalse;
        }    
   
    return retVal;
    }

/**
 *  Creates RSSmStateAwareSession class instance
 */
void CTestRSsmStateManager::DoCmdNew()
    {
    INFO_PRINTF1(_L("Create RSsmStateManager instance"));
    DoCleanup();
    
    TRAPD( err, iSsmStateManager = new (ELeave)RSsmStateManager());
    if (err!=KErrNone)
        {
        ERR_PRINTF2(_L("new error %d"), err);
        SetError(err);
        }        
    }

/**
 * Close RSsmStateManager handle
 */
void CTestRSsmStateManager::DoCmdClose()
    {
    INFO_PRINTF1(_L("Close RSsmStateManager "));
    iSsmStateManager->Close();
    }

/**
 * Contains cleanup implementation
 */
void CTestRSsmStateManager::DoCleanup()
    {
    if(iSsmStateManager != NULL)
        {
        INFO_PRINTF1(_L("Deleting current RSsmStateManager"));
        delete iSsmStateManager;
        iSsmStateManager = NULL;
        }
    }

/** 
 * Destroy RSsmStateManager object
 */
void CTestRSsmStateManager::DoCmdDestructor()
    {
    INFO_PRINTF1(_L("Destroying the object"));
    DoCleanup();
    }

/**
 * Connects to Ssm State Manager
 */
void CTestRSsmStateManager::DoCmdConnect()
    {     
    TInt  err = iSsmStateManager->Connect();          
    if (KErrNone != err)
        {
        ERR_PRINTF2(_L("Connect() error %d"), err);
        SetError(err);   
        }    
    }

/**
 * RequestStateTransition in case of State transition request
 */
void CTestRSsmStateManager::DoCmdRequestStateTransition(const TDesC& aSection, const TInt aAsyncErrorIndex)
    {     
    TPtrC getMainState;
    TPtrC getSubStates;    
    if (!GetStringFromConfig(aSection, KMainState(), getMainState ))
        {
        //set default value if value is not provided in .ini file
        getMainState.Set( _L("ESsmNormal"));
        }
    if (!GetStringFromConfig(aSection, KSubState(), getSubStates ))
        {
        //set default value if value is not provided in .ini file
        getSubStates.Set(_L("ESsmNormalRfOffSubState"));
        }
    TUint16 mainState;
    TUint16 subState;
    if ( MapToMainState( getMainState, mainState )&& MapToSubState( getSubStates, subState ))
        {
        TInt reason;
        if (!GetIntFromConfig(aSection, KReason(), reason ))
            {
            //set default reason if value is not provided in .ini file
            reason = KErrNone;
            }    
        
        TSsmStateTransition stateTransition(mainState, subState, reason );
        //Call the API depending on async call or not
        TBool async;
        if (!GetBoolFromConfig(aSection, KAsync(), async ))
            {
            async = EFalse;
            }
        if (async)
            {
            iSsmStateManager->RequestStateTransition(stateTransition, iActiveNotifyOnChange->iStatus);
            iActiveNotifyOnChange->Activate(aAsyncErrorIndex);
            IncOutstanding();
            }
        else
            {
            TInt err = iSsmStateManager->RequestStateTransition(stateTransition); 
            if (err != KErrNone)
                {
                ERR_PRINTF2(_L("RequestStateTransition() failed with error %d"), err);
                SetError(err);
                }
            }        
        } 
    else
        {
        ERR_PRINTF1(_L(" Mapping state/substate failed%d"));
        SetBlockResult(EFail);
        }
    }

/**
 * RequestStateTransitionCancel
 */
void CTestRSsmStateManager::DoCmdRequestStateTransitionCancel()
    {    
    iSsmStateManager->RequestStateTransitionCancel();
    }

/**
 Virtual RunL - Called on completion of an asynchronous command
 @param aActive Active Object that RunL has been called on
 @pre N/A
 @post N/A
 @leave system wide error code
 @see MTPActiveCallback
*/
void CTestRSsmStateManager::RunL(CActive* aActive, TInt aIndex)
    {
    INFO_PRINTF1(_L("RSsmStateManager->RunL()is called")); 
    if (aActive == iActiveNotifyOnChange)
        {
        TInt    err=iActiveNotifyOnChange->iStatus.Int();
        if ( err != KErrNone )
            {
            ERR_PRINTF2(_L("RunL Error %d"), err);
            SetAsyncError(aIndex, err);
            }
        }
    DecOutstanding();   
    }

/**
 Virtual DoCancel - Request to cancel the asynchronous command
 @param aActive Active Object that DoCancel has been called on
 @pre - N/A
 @post - N/A
 @leave system wide error code
 @see MTPActiveCallback
*/
void CTestRSsmStateManager::DoCancel(CActive* aActive, TInt aIndex)
    {
    INFO_PRINTF1(_L("DoCancel"));
    if( aActive ==  iActiveNotifyOnChange ) 
        {        
        TInt err =  iActiveNotifyOnChange->iStatus.Int(); 
        if (err!=KErrNone)
            {
            ERR_PRINTF2(_L("DoCancel Error %d"), err);
            SetAsyncError(aIndex, err);
            }
        }   
    DecOutstanding();       
    }
/**
 * Helper method to Map defined MainState on ssmstates.hrh
 */
TBool CTestRSsmStateManager::MapToMainState( TPtrC& aGetMainState, TUint16& aMainState )
    {
    TInt ret = ETrue;
    if(!(aGetMainState.Compare(_L("ESsmStartup"))))
        {
        aMainState = ESsmStartup;
        }
    else if(!(aGetMainState.Compare(_L("ESsmNormal"))))
        {
        aMainState = ESsmNormal;
        }    
    else if(!(aGetMainState.Compare(_L("ESsmShutdown"))))
        {
        aMainState = ESsmShutdown;
        }
    else if(!(aGetMainState.Compare(_L("ESsmFail"))))
        {
        aMainState = ESsmFail;
        }
    else if(!(aGetMainState.Compare(_L("ESsmRestore"))))
        {
        aMainState = ESsmRestore;
        }
    else if(!(aGetMainState.Compare(_L("ESsmEmergencyCallsOnly"))))
        {
        aMainState = ESsmEmergencyCallsOnly;
        }    
    else
        {
        ret = EFalse;
        }
    return ret;
    }

/**
 * Helper method to Map defined SubState in ssmsubstates.hrh..Need to be extended for other substates
 */
TBool CTestRSsmStateManager::MapToSubState( TPtrC& aGetSubState, TUint16& aSubState )
    {
    TInt ret = ETrue;
    if(!(aGetSubState.Compare(_L("ESsmNormalRfOffSubState"))))
        {
        aSubState = ESsmNormalRfOffSubState;
        }
    else if(!(aGetSubState.Compare(_L("ESsmNormalSubState"))))
        {
        aSubState = ESsmNormalSubState;
        }
    else if(!(aGetSubState.Compare(_L("ESsmNormalRfOnSubState"))))
        {
        aSubState = ESsmNormalRfOnSubState;
        }    
    else
        {
        ret = EFalse;
        }
    return ret;
    }