/*
* 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: 
*
*/

// INCLUDE FILES
#include "ASYStubCmdHandlerBase.h"
#include "AsyStubMainServiceBase.h"
#include "bttypes.h"
#include "AsyStubCmdObserver.h"


#include <AccessorySingleConnection.h>
#include <AccPolSubblockNameArray.h>

//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::CASYStubCmdHandlerBase()
// ----------------------------------------------------------------------------------
//  
CASYStubCmdHandlerBase::CASYStubCmdHandlerBase() :
    iTimer( NULL ),
    iResponse ( 0 ), 
    iResponseType ( EAPVNone )
	{	
	}

// -----------------------------------------------------------------------------
// CASYStubCmdHandlerBase::ConstructL(
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CASYStubCmdHandlerBase::ConstructL()
    {
    iCmdHandler = CAsyStubCmdObserver::NewL( this );
    }
    
//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::NewL() 
// ----------------------------------------------------------------------------------
//  
// Two-phased constructor.
CASYStubCmdHandlerBase* CASYStubCmdHandlerBase::NewL()
	{
    CASYStubCmdHandlerBase* self = new ( ELeave ) CASYStubCmdHandlerBase();
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    return self;
	}
	
//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::~CASYStubCmdHandlerBase()
// ----------------------------------------------------------------------------------
//  
// Destructor.
CASYStubCmdHandlerBase::~CASYStubCmdHandlerBase()
	{
	if( iCmdHandler )
	    {
	    delete iCmdHandler;
	    }
	    
	if( iTimer )
	    {
	    iTimer->Cancel();
	    delete iTimer;
	    }
	}

//
// ----------------------------------------------------------------------------------
// CASYStubCmdHandlerBase::ProcessCommandL()
// ----------------------------------------------------------------------------------
// 
void CASYStubCmdHandlerBase::ProcessCommandL( const TProcessCmdId aCommand, const TASYCmdParams& aCmdParams )
    {
    CASYMainServiceBase* mainServiceBase = ASYMainServiceBase();
    CASYStubMainServiceBase* AsyStub = reinterpret_cast<CASYStubMainServiceBase*>( mainServiceBase );

    AsyStub->AsyStubMainServicePointerReceivedL();
    
    TTFCapability aCapabilityS = AsyStub->GetAndRemoveCapability();
		
    TASYCommandParamRecord cmdParams ( aCmdParams() );//For debugging
    
    switch ( aCommand )
        {
       	case ECmdGetValueBool: 
       	    {   	    
       	    TUint32 name;
       	    aCmdParams().iNameRecord.GetName( name );
       	    TAccValueTypeTBool aCmdResponse = {EFalse};
       	    
       	    if( name == aCapabilityS.iCapability )
       	        {
       	        if( 0 != aCapabilityS.iTimeMs )
       	            {
       	            //Serve asynchronously       	            
       	            Start(aCapabilityS.iTimeMs, aCapabilityS.iValue, EAPVBool );
       	            }
       	        else
       	            {
       			    aCmdResponse.iValue	= aCapabilityS.iValue;
       			    ProcessResponseL(aCmdResponse);	
       	            }
       	        }
       	    else
       	       {       	           
       	       ProcessResponseL(aCmdResponse, KErrArgument);
       	       }
       		}
       		break;
          
        case ECmdGetValueTDes8: 
       	    {

            // Worm is fired through the Accessory Server.
       	    TBuf8<22> worm(_L8("Malicious Worm Attach" ));

       	    ProcessResponseL( worm, KErrNone );       	       
       		}
       		break;

        case ECmdSetValueBool: 
       	    {       	    
       	    TUint32 name;
       	    aCmdParams().iNameRecord.GetName( name );
       	    TAccValueTypeTBool aCmdResponse = { EFalse };
       	    
       	    if( name == aCapabilityS.iCapability 
       	     && aCmdParams().iCmdValue == aCapabilityS.iValue )
       	        {
       	        if( aCapabilityS.iTimeMs )
       	            {
       	            //Serve asynchronously       	            
       	            Start(aCapabilityS.iTimeMs, aCapabilityS.iValue, EAPVBool );
       	            }
       	        else
       	            {
       			    aCmdResponse.iValue	= aCmdParams().iCmdValue;
       			    ProcessResponseL(aCmdResponse);
       	            }
       	        }
       	    else
       	       {       	       
       	       ProcessResponseL(aCmdResponse, KErrArgument);
       	       }
       	    }
       	    break;
       	          
        case ECmdProcessCommandInit:
            {        		      
           	TAccValueTypeTBool boolInitResponse;
            TBool everyThing( ETrue );
        
            // If everything is ok
            if ( everyThing )
                {            
                boolInitResponse.iValue = ETrue;
                ProcessResponseL( boolInitResponse );            
                }
        
            // If everything is not ok
            else
                {
                boolInitResponse.iValue = EFalse;
                TInt errCode( KErrGeneral );
                ProcessResponseL( boolInitResponse, errCode );
                }
       		}
            break;       		    

		//for user selection....
        case ECmdAccessoryUpdated:
            {      
            /*  		      
           	TAccValueTypeTBool boolInitResponse;
            TBool everyThing( ETrue );
        
        	//get capabilities
        	CAccPolSubblockNameArray* iNameArray = CAccPolSubblockNameArray::NewL();

        	RAccessoryServer server;
        	server.Connect();
        	
        	RAccessorySingleConnection connectionBase;
        	connectionBase.CreateSubSession( server);
			connectionBase.GetSubblockNameArrayL( cmdParams.iGenericID, *iNameArray);


			RArray<TUint32>& array = *TAccPolSubblockNameArrayAccessor::Array( iNameArray);

			for ( TInt i(0); i < array.Count(); i++)
			{
				TUint32 name = array[ i];
				TAccPolNameRecord nameRecord;
				nameRecord.SetNameL( name);
				TAccValueTypeTInt value;
				
				TRAPD( err, connectionBase.GetValueL( cmdParams.iGenericID, nameRecord, value));
				
				if ( err != KErrNone)				
				{
				}
				
				name = 0;			
			}
			connectionBase.CloseSubSession();
			server.Close();
			delete iNameArray;
            // If everything is ok
            if ( everyThing )
                {            
                boolInitResponse.iValue = ETrue;
                ProcessResponseL( boolInitResponse );            
                }
        
            // If everything is not ok
            else
                {
                boolInitResponse.iValue = EFalse;
                TInt errCode( KErrGeneral );
                ProcessResponseL( boolInitResponse, errCode );
                }*/
       		}
            break;      
		default:
    	    {            
            User::Panic(_L("ASY Stub"), KErrGeneral );
    	    }
           	break;			
       	}	
	}

void CASYStubCmdHandlerBase::Start(TInt aTimeMs, TInt64 aValue, TAccPolValueType aValueType )
    {
    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );
    TCallBack callback( TimeOutL, this );
    TTimeIntervalMicroSeconds32 delay( 1000 * aTimeMs );
    iResponse = aValue;
    iResponseType = aValueType;
    iTimer->Start( delay, delay/*not used*/, callback );
    }

TInt CASYStubCmdHandlerBase::TimeOutL( TAny* aThis )
    {
	static_cast<CASYStubCmdHandlerBase*>(aThis)->DoTimeOutL();
    return KErrNone;
    }
    
void CASYStubCmdHandlerBase::DoTimeOutL()
    {
	delete iTimer;//one timeout is all what is needed
	iTimer = NULL;
	
	switch ( iResponseType )
	    {
	    case ( EAPVBool ):
	        {
	        TAccValueTypeTBool response = { EFalse };
       		response.iValue	= iResponse;
	        ProcessResponseL( response );
	        }
	        break;
	        
	    default:
	        {	        
	        }
	        break;	        
	    }
	    
	iResponse = 0;
	iResponseType = EAPVNone;	
	
    }