/*
* Copyright (c) 2006-2007 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:  Implements logging service handler (This will be part of 
*									Ecom plugin.
*
*/

#include <liwserviceifbase.h>
#include <liwcommon.h>
#include <logwrap.h>
#include <ecom/implementationproxy.h>
#include "logclientchangeobserver.h"
#include "logiter.h"
#include "loggingservicehandler.h"
#include "logginginterface.h"

/**
* @Default constructor 
*/ 
CLogServiceHandler :: CLogServiceHandler()
    {
    }

/**
* @Default destructor 
*/ 
CLogServiceHandler :: ~CLogServiceHandler()
    {
    }

/**
* Two phased constructor implementation
*/
EXPORT_C CLogServiceHandler* CLogServiceHandler :: NewL()
    {
    CLogServiceHandler* self = CLogServiceHandler::NewLC();
    CleanupStack::Pop(self);
    return self; 
    }

/**
* Two phased constructor implementation
*/
CLogServiceHandler* CLogServiceHandler :: NewLC() 
    {
    CLogServiceHandler* self = new (ELeave) CLogServiceHandler();
    CleanupStack::PushL(self);
    return self;
    }

/**
* Called by the AIW framework to initialise provider with necessary information 
* from the Service Handler. This method is called when the consumer makes 
* the attach operation.         
*
* @param aFrameworkCallback callback handle function
* @param aInterest consumer application's intrest
*/
void CLogServiceHandler::InitialiseL( MLiwNotifyCallback& /*aFrameworkCallback*/,
                                      const RCriteriaArray& aInterest )
    {
    TInt count = aInterest.Count() ;
    for ( TInt i = 0; i < count; i++ )
        {
        if ( aInterest[i]->ContentType() == KLoggingContents ) 
            {
            iContentType = KLoggingContents;
            return;
            }
        }
    User::Leave( KErrNotFound );
    }

/**
* Executes generic service commands included in criteria, derived from CLiwServiceIfBase
* 
* @param aCmdId Command to be executed.
* @param aInParamList Input parameters, can be an empty list.
* @param aOutParamList Output parameters, can be an empty list.
* @param aCmdOptions Options for the command, see KLiwOpt* in LiwCommon.hrh.
* @param aCallback Callback for asynchronous command handling, parameter checking, etc.
*/
void CLogServiceHandler :: HandleServiceCmdL( const TInt& aCmdId,
                                              const CLiwGenericParamList& aInParamList,
                                              CLiwGenericParamList& aOutParamList,
                                              TUint aCmdOptions,
                                              const MLiwNotifyCallback* aCallback )
    {
    TRAPD( error , CmdExecuteL( aCmdId , aInParamList, aOutParamList ,aCmdOptions , aCallback ) ) ;
    
    if ( error )
    	{
    	TInt sapierror = CLoggingInterface::ConvertToSapiError( error );
    	aOutParamList.AppendL( TLiwGenericParam( KErrorCode , TLiwVariant( sapierror ) ) ) ;	
    	}
    else
    	{
    	aOutParamList.AppendL( TLiwGenericParam( KErrorCode , TLiwVariant( error ) ) ) ;
    	}
    }

/**
* CLogServiceHandler::CmdExecuteL, this method is called by CLogServiceHandler::HandleCmdL()
* to catch any leaves that might occur during execution of a LiwCommand. 
*/
void CLogServiceHandler::CmdExecuteL( const TInt& aCmdId,
        	                          const CLiwGenericParamList& aInParamList,
        	                          CLiwGenericParamList& aOutParamList,
        	                          TUint /*aCmdOptions */,
        	                          const MLiwNotifyCallback* /*aCallback*/ )
    {
    TLiwGenericParam r;
    const TLiwGenericParam* p = NULL;
    CLoggingInterface *interfaceLogging ;
    aOutParamList.Reset() ;
    
    if ( aCmdId == KLiwCmdAsStr ) 
        {
        TInt pos = 0;
        p = aInParamList.FindFirst(pos, _L8("cmd")); 
        }
    
    if ( p && ( p->Value().AsData() == KDsInterfaceName ) ) 
        {
        if ( iContentType == KLoggingContents )
    		{
    		interfaceLogging  = CLoggingInterface :: NewL() ;
    		CleanupStack :: PushL( interfaceLogging ) ;
    		aOutParamList.AppendL(TLiwGenericParam(KDsInterfaceName , TLiwVariant(interfaceLogging))) ;
    		}//End of KLoggingContents
    	} //End of KLsInterface
    
    else 
        {
        aOutParamList.AppendL(TLiwGenericParam(KErrorCode , TLiwVariant((TInt32)KErrGeneral)));
        aOutParamList.AppendL(TLiwGenericParam(KErrorMessage,TLiwVariant(KInterfaceMissing())));
        }
      
    aOutParamList.AppendL( TLiwGenericParam( KErrorCode , TLiwVariant( KErrNone ) ) ) ;
    CleanupStack :: Pop ( interfaceLogging ) ;
        
    return;
    }

/**
*   Map the interface UIDs to implementation factory functions
*/       
const TImplementationProxy ImplementationTable[] =
{
IMPLEMENTATION_PROXY_ENTRY( 0x2000CFC1, CLogServiceHandler::NewL )
};

/**
*  Exported proxy for instantiation method resolution
*/   
EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )
    {
    aTableCount = sizeof( ImplementationTable ) / sizeof( TImplementationProxy );
    return ImplementationTable;
    }