/*
* 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 interface class for logging sapi
*
*/


#include <e32base.h>
#include <e32def.h>
#include <f32file.h>
#include <cntdef.h>
#include <logwrap.h>
#include <logwrap.hrh>
#include <liwserviceifbase.h>
#include <LiwCommon.h>
#include <ecom/ImplementationProxy.h>
#include  <utf.h>
#include "loggingasyncservice.h"


#include "LOGCLIENTCHANGEOBSERVER.H"
#include "logiter.h"
#include "loggingservice.h"
#include "loggingasyncservice.h"
#include "loggingsyncservice.h"
#include "loggingevent.h"
#include "loggingfilter.h"
#include "loggingcallbackslot.h"
#include "logobserver.h"
#include "logginginterface.h"
#include "liwlogiter.h"
#include "loggingcallback.h"



/**
 * Default Constructor Method
 */
CLoggingInterface :: CLoggingInterface()
    {
    }
    
/**
 * Default Destructor
 */
CLoggingInterface :: ~CLoggingInterface()
    {
    delete iErrorString;
    delete iLogService;
    }

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

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

/**
 * This function constructs the member elements of CLoggingInterface Class
 */
void CLoggingInterface :: ConstructL()
    {
    iLogService = CLoggingService::NewL();
    }

/**
 * closes the interface
 */
void CLoggingInterface::Close()
    {
    delete this;
    }

/**
 * Convert to sapiError Function
 */
TInt  CLoggingInterface::ConvertToSapiError( TInt aSymbianErr )
    {
    TInt sapiErr( SErrGeneralError );

    switch ( aSymbianErr )
        {
        case KErrArgument:
            {
            sapiErr = SErrBadArgumentType;
            break;
            }
        case KErrNotSupported:
            {
            sapiErr = SErrServiceNotSupported;
            break;
            }
        case KErrServerBusy:
            {
            sapiErr = SErrServerBusy;
            break;
            }
        case KErrGeneral:
            {
            sapiErr = SErrGeneralError;
            break;
            }
        case KErrCancel:
            {
            sapiErr = SErrCancelSuccess;
            break;
            }
        case KErrNone:
            {
            sapiErr= SErrNone;
            break;
            }
        case KErrNotFound:
            {
            sapiErr= SErrNotFound;
            break;
            }
        case KErrNoMemory:
            {
            sapiErr = SErrNoMemory;
            break;
            }
        case KErrInUse:
            {
            sapiErr = SErrServiceInUse;
            break;
            }
        case KErrNotReady:
            {
            sapiErr = SErrServiceNotReady;
            break;
            }
        case SErrMissingArgument:
            {
            sapiErr = SErrMissingArgument;
            break;
            }
        case SErrInvalidServiceArgument :
            {
            sapiErr = SErrInvalidServiceArgument;
            break;    
            } 
        }
    return sapiErr;
    }

void CLoggingInterface::CheckInputTypeL( const TLiwVariant* aSource, LIW::TVariantTypeId aExpectedtype, const TDesC8* aErrorArgument )
    {
    if( aSource->TypeId() != aExpectedtype )
        {
        iErrorString = HBufC::NewL(KMaxMsgSize);
        TPtr ptr(iErrorString->Des());
        TBuf<KMaxKeySize> buf;
        buf.Copy( *aErrorArgument );
        ptr.Append(buf);
        ptr.Append( KInvalid.operator()());
        ((TLiwVariant*)aSource)->Reset();
        User::Leave( KErrArgument );
        }
    }

void CLoggingInterface::IncorrectValueL( const TDesC8* aErrorArgument )
    {
    iErrorString = HBufC::NewL(KMaxMsgSize);
    TPtr ptr(iErrorString->Des());
    TBuf<KMaxKeySize> buf;
    buf.Copy( *aErrorArgument );
    ptr.Append(buf);
    ptr.Append( KInvalid.operator()());
    }

void CLoggingInterface::MissingValueL( const TDesC8* aErrorArgument )
    {
    iErrorString = HBufC::NewL(KMaxMsgSize);
    TPtr ptr(iErrorString->Des());
    TBuf<KMaxKeySize> buf;
    buf.Copy( *aErrorArgument );
    ptr.Append(buf);
    ptr.Append( KMissing.operator()());
    User::Leave( SErrMissingArgument );
    }

/**
 * Function : ExecuteCmdL , called directly by consumer, parses the input parameters and
 * then calls appropriate method on iLocationService object
 */
void CLoggingInterface :: ExecuteCmdL( const TDesC8& aCmdName,
                                       const CLiwGenericParamList& aInParamList,
                                       CLiwGenericParamList& aOutParamList,
                                       TUint aCmdOptions,
                                       MLiwNotifyCallback* aCallback )
    {
    TRAPD( error , CmdExecuteL( aCmdName , aInParamList , aOutParamList , aCmdOptions , aCallback ) ) ;
    if( error != KErrNone )
        {
        if( iErrorString )
            {
            TBuf<150> errorMessage;
            errorMessage.Append( KMsgErr.operator()() );
            TBuf<40> commandName;
            commandName.Copy( aCmdName );
            errorMessage.Append( commandName );
            errorMessage.Append( KColon.operator()());
            
            errorMessage.Append( iErrorString->Des() );
            
            aOutParamList.AppendL(TLiwGenericParam( KErrorMessage,
                        TLiwVariant( errorMessage )));
            delete iErrorString;
            iErrorString = NULL;
            }
        }
    TInt sapierror = ConvertToSapiError( error );
    aOutParamList.AppendL(TLiwGenericParam(KErrorCode , TLiwVariant((TInt32)sapierror))) ;
    }

/**
 * CLoggingInterface::CmdExecuteL, this method is called by CLoggingInterface::HandleCmdL()
 * to catch any leaves that might occur during execution of a LiwCommand.
 *
 * @param aCmdName the name of the service command which the consumer wants to invoke
 * @param aInParamList the input parameter list, can be empty list
 * @param [in,out] aOutParamList the output parameter list, can be empty lis. The
 * service provider can use the output parameter list to fill in necessary return values
 * @param aCmdOptions Options for the command, see TLiwServiceCmdOptions in LiwCommon.hrh.
 * @param aCallback callback to be registered by consumer application
 * @see TLiwServiceCmdOptions
 * @see CLiwGenericParamList
 * @see MLiwNotifyCallback
 */
void CLoggingInterface :: CmdExecuteL( const TDesC8& aCmdName,
                                       const CLiwGenericParamList& aInParamList,
                                       CLiwGenericParamList& aOutParamList,
                                       TUint aCmdOptions,
                                       MLiwNotifyCallback* aCallback )
    {
    aOutParamList.Reset() ;
    
    if(!aCmdName.CompareF( KCmdCancel ))
        {
        if( aCmdOptions & KLiwOptCancel )
            {
            TInt ret = 0 ;
            
            const TLiwGenericParam *transidparam = aInParamList.FindFirst( ret , KTransactionId ) ;
            
            if(!transidparam && ( aInParamList.Count() > 0 ) )
                {
                transidparam  = &(aInParamList[EIndex0])  ;
                
                if( transidparam->Name().Compare( KNullDesC8 ) )
                    {
                    MissingValueL( KTransactionId.operator&() );
                    }
                }
                
            if( !transidparam )
                {
                MissingValueL( KTransactionId.operator&() );
                }
                
            CheckInputTypeL( &transidparam->Value(), LIW::EVariantTypeTInt32, KTransactionId.operator&() );  
            TInt32 transid = (transidparam->Value()).AsTInt32() ;
            
            if( transid<0 )
                {
                IncorrectValueL( KTransactionId.operator&() );
                User::Leave( KErrNotFound );
                }
                
            ret = iLogService->CancelServiceL( transid ) ;
            
            if( ret == KErrNotFound )
                {
                IncorrectValueL( KTransactionId.operator&() );
                User::Leave( KErrNotFound );
                }
                
            return ;
            }
        }
        
    else if(!aCmdName.CompareF( KCmdAdd ))
        {
        TBool indexBaseInp = ETrue;
        TInt Index = 0 ;
        
        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;
        
        if( !contentType && ( aInParamList.Count() > 0 ) )
            {
            contentType = &(aInParamList[EIndex0]) ;
            
            if( contentType->Name().Compare( KNullDesC8 ) )
                {
                MissingValueL( KContentTypeKey.operator&() );
                }
            }
        else
            {
            indexBaseInp = EFalse ;
            }
           
        if( !contentType )
            {
            MissingValueL( KContentTypeKey.operator&() );
            }
        
        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC, KContentTypeKey.operator&() );
        TPtrC content = (contentType->Value()).AsDes() ;
        
        if(content.CompareF( KContentType ))
            {
            IncorrectValueL( KContentTypeKey.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
        
        TInt index = 0 ;
        const TLiwGenericParam *eventdetails = NULL ;
        TUint transid ;
        
        if ( indexBaseInp ) 
            {
            if( aInParamList.Count() > 1 )
                {
                eventdetails  = &(aInParamList[EIndex1]) ;
                }
            }
        else
            {
            eventdetails = aInParamList.FindFirst( index , KEventDetails );
            }    
        
        if( !eventdetails )
            {
            MissingValueL( KEventDetails.operator&() );
            }
        
        TInt32  ret = AddEventL( eventdetails, transid, aCmdOptions, aCallback ) ;
        
        if( aCallback )
            {
            aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant ( ( TInt32 )transid ) ) ) ;
            }
        else
            {
            TBuf<8> des;
            des.Num( ret );
            aOutParamList.AppendL( TLiwGenericParam( KResponse , TLiwVariant( des ) ) ) ;
            }
        }
    
    else if(!aCmdName.CompareF( KCmdGetList ))
        {
        TBool indexBaseInp = ETrue;
        TInt Index = 0 ;
        
        const TLiwGenericParam *contentType = aInParamList.FindFirst(Index , KContentTypeKey) ;
        
        if( !contentType && ( aInParamList.Count() > 0 ) )
            {
            contentType = &(aInParamList[EIndex0]) ;
            
            if( contentType->Name().Compare( KNullDesC8 ) )
                {
                MissingValueL( KContentTypeKey.operator&() );
                }
            }
         else
            {
            indexBaseInp = EFalse ;
            }    
        
        if( !contentType )
            {
            MissingValueL( KContentTypeKey.operator&() );
            }
        
        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC ,KContentTypeKey.operator&() );
        TPtrC content = (contentType->Value()).AsDes() ;
        
        if( content.CompareF( KContentType ) )
            {
            IncorrectValueL( KContentTypeKey.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
        
        TInt index = 0 ;
        const TLiwGenericParam *flrParam = NULL ;
        TUint transid ;
       
        if ( indexBaseInp ) 
            {
            if( aInParamList.Count() > 1 )
                {
                flrParam = &aInParamList[EIndex1] ;
                }
            }
        else
            {
            flrParam = aInParamList.FindFirst( index , KFilter ) ; 
            }    
        
       
       CLogIter *iter = this->GetListL(flrParam , transid ,aCmdOptions, aCallback) ;
              
        /*Ownership of logiter will be with the consumer*/
        if( aCallback )
            {
            aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant( ( TInt32 )transid ) ) ) ;
            }
        else
            {
            CLiwLogIter *logiter = CLiwLogIter :: NewL( iter ) ;
            CleanupClosePushL( *logiter );
            aOutParamList.AppendL( TLiwGenericParam( KResponse , TLiwVariant( logiter ) ) ) ;
            CleanupStack :: Pop( logiter ) ;
            logiter->DecRef() ;
            }
        }
     
    else if(!aCmdName.CompareF( KCmdRequestNotification ))
        {
        TBool indexBaseInp = ETrue;
        TInt Index = 0 ;
        
        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;
        
        if( !contentType && ( aInParamList.Count() > 0 ) )
            {
            contentType = &(aInParamList[EIndex0]) ;
            
            if( contentType->Name().Compare( KNullDesC8 ) )
                {
                MissingValueL( KContentTypeKey.operator&() );
                }
            }
        else
            {
            indexBaseInp = EFalse ;
            }    
        
        if( !contentType )
            {
            MissingValueL( KContentTypeKey.operator&() );
            }
        
        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC, KContentTypeKey.operator&() );
        
        TPtrC content = (contentType->Value()).AsDes() ;
        
        if(content.CompareF( KContentType ))
            {
            IncorrectValueL( KContentTypeKey.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
                
        TInt index = 0 ;
        TUint transid ;
        const TLiwGenericParam *interval = NULL ;
        
        if ( indexBaseInp ) 
            {
            if( aInParamList.Count() > 1 )
                {
                interval = &(aInParamList[EIndex1]) ;
                }
            }
        else
            {
            interval = aInParamList.FindFirst( index , KFilter ) ;
            }    
        
       if( !interval )
            {
            MissingValueL( KFilter.operator&() );
            }
        
        this->RequestNotificationsL( interval, aCallback, transid, aCmdOptions ) ;
        
        aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant( ( TInt32 )transid ) ) ) ;
        }
    
    else if(!aCmdName.CompareF( KCmdDelete ))
        {
        TBool indexBaseInp = ETrue;
        TInt Index = 0 ;
        
        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;
        
        if( !contentType && ( aInParamList.Count() > 0 ))
            {
            contentType = &(aInParamList[EIndex0]) ;
            
            if( contentType->Name().Compare( KNullDesC8 ) )
                {
                MissingValueL( KContentTypeKey.operator&() );
                }
            }
        else
            {
            indexBaseInp = EFalse ;
            }        
        
        if( !contentType )
            {
            MissingValueL( KContentTypeKey.operator&() );
            }
        
        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC ,KContentTypeKey.operator&() );
        
        TPtrC content = (contentType->Value()).AsDes() ;
        
        if(content.CompareF(KContentType))
            {
            IncorrectValueL( KContentTypeKey.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
        
        TInt index = 0;
        TUint transid;
        const TLiwGenericParam *logid = NULL ;
        
        if ( indexBaseInp ) 
            {
            if( aInParamList.Count() > 1 )
                {
                logid = &aInParamList[EIndex1] ;
                }
            }
        else
            {
            logid = aInParamList.FindFirst( index , KData ) ;
            }    
        
        if( !logid )
            {
            MissingValueL( KData.operator&() );
            }
        
        TInt ret = DeleteEventL( logid, transid, aCmdOptions, aCallback );
        
        if( ret != KErrNone )
            {
            IncorrectValueL( KLogId.operator&() );
            User::Leave( KErrNotFound );
            }
        
        if( aCallback )
             {
             aOutParamList.AppendL(TLiwGenericParam( KTransactionId , TLiwVariant( ( TInt32 )transid ) ) ) ;
             }
        }
    
    else
        {
        iErrorString = KErrLogCmdName.operator()().Alloc();
        User :: Leave( KErrNotSupported ) ;
        }
    }

/**
 * Internal utility method, used to Add from the core class
 *
 * @param aeventdetails,
 * @param aTransId,
 * @param aCallback, callback method for async events
 */
TInt32 CLoggingInterface::AddEventL( const TLiwGenericParam *eventdetails ,
                                     TUint& aTansId ,
                                     TUint aCmdOptions,
                                     MLiwNotifyCallback* aCallback )
    {
    CheckInputTypeL( &eventdetails->Value(), LIW::EVariantTypeMap, KEventDetails.operator&() );
    
    CLogsEvent *event  = CLogsEvent :: NewL() ;
    
    CleanupStack :: PushL( event ) ;
    
    const CLiwMap *evtmap = (eventdetails->Value()).AsMap() ;
    
    if( !evtmap )
        {
        MissingValueL( KEventDetails.operator&() );
        }
    
    TLiwVariant mapVar;
    
    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &mapVar) );
    
    /**
    * Extract the contents of Add Event Details
    * and issue request to the core class  accordingly
    */
    if( evtmap->FindL( KEventTypeKey , mapVar ) )
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KEventTypeKey.operator&() );
        TUid val = TUid::Null() ;
        
        switch( mapVar.AsTInt32() )
            {
            case EKLogCallEventType :
                {
                val =  TUid :: Uid( KLogCallEventType );
                break ;
                }
            
            case EKLogDataEventType :
                {
                val = TUid :: Uid ( KLogDataEventType );
                break ;
                }
            
            case EKLogFaxEventType :
                {
                val = TUid :: Uid ( KLogFaxEventType );
                break ;
                }
            
            case EKLogShortMessageEventType :
                {
                val = TUid :: Uid ( KLogShortMessageEventType );
                break ;
                }
                
            case EKLogPacketDataEventType :
                {
                val = TUid :: Uid ( KLogPacketDataEventType ) ;
                break ;
                }     
            
            default :
                {
                mapVar.Reset();
                IncorrectValueL( KEventTypeKey.operator&() ); 
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        event->SetEventType( val ) ;
        }
    else
        {
        mapVar.Reset();
        MissingValueL( KEventTypeKey.operator&() );
        }
    
    if( evtmap->FindL( KRemotePartyKey , mapVar ) )
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KRemotePartyKey.operator&() );
        event->SetRemoteParty(mapVar.AsDes()) ;
        }
    
    if(evtmap->FindL( KDirectionKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KDirectionKey.operator&() );
        TInt val = 0 ;
        
        switch(mapVar.AsTInt32())
            {
            case EIncomingEvent :
                {
                val = R_LOG_DIR_IN ;
                break ;
                }
        
            case EOutgoingEvent :
                {
                val = R_LOG_DIR_OUT ;
                break ;
                }
        
            case EIncomingEventAlternateline :
                {
                val = R_LOG_DIR_IN_ALT ;
                break ;
                }
        
            case EOutgoingEventAlternateline :
                {
                val = R_LOG_DIR_OUT_ALT  ;
                break ;
                }
        
            case  EFetchedEvent :
                {
                val = R_LOG_DIR_FETCHED ;
                break ;
                }
        
            case EMissedEvent :
                {
                val = R_LOG_DIR_MISSED ;
                break ;
                }
        
            case EMissedEventAlternateline :
                {
                val = R_LOG_DIR_MISSED_ALT ;
                break ;
                }
                
            default :
                {
                mapVar.Reset();
                IncorrectValueL( KDirectionKey.operator&() );  
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        
        if( val )
            {
            event->SetDirection( val ) ;
            }
        }
    
    
    if(evtmap->FindL(KEventDurationKey , mapVar))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KEventDurationKey.operator&() );
        
        if( mapVar.AsTInt32()<0 )
              {
              mapVar.Reset();
              IncorrectValueL( KEventDurationKey.operator&() );
              User::Leave( SErrInvalidServiceArgument );
              }
        event->SetDurationType( KLogDurationValid ) ;
        event->SetDuration( mapVar.AsTInt32() ) ;
        }
    
    if(evtmap->FindL( KDeliveryStatusKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KDeliveryStatusKey.operator&() );
        TInt val = 0 ;
        
        switch( mapVar.AsTInt32() )
            {
            case EStatusPending :
                {
                val =  R_LOG_DEL_PENDING ;
                break ;
                }
        
            case EStatusSent :
                {
                val = R_LOG_DEL_SENT ;
                break ;
                }
        
            case EStatusFalied :
                {
                val = R_LOG_DEL_FAILED ;
                break ;
                }
        
            case EStatusNone :
                {
                val = R_LOG_DEL_NONE  ;
                break ;
                }
        
            case  EStatusDone :
                {
                val = R_LOG_DEL_DONE ;
                break ;
                }
        
            case EStatusNotSent :
                {
                val = R_LOG_DEL_NOT_SENT ;
                break ;
                }
        
            case EStatusScheduled :
                {
                val = R_LOG_DEL_SCHEDULED ;
                break ;
                }
                
            default :
                {
                mapVar.Reset();
                IncorrectValueL( KDeliveryStatusKey.operator&() );  
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        
        if( val )
            {
            event->SetStatus( val ) ;
            }
        }
    
    if(evtmap->FindL(KFlagsKey , mapVar))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KFlagsKey.operator&() );
        TUint8 val = 0 ;
        
        switch(mapVar.AsTInt32())
            {
            case EKLogEventContactSearched :
                {
                val = KLogEventContactSearched ;
                break ;
                }
            
            case EKLogEventRead :
                {
                val = KLogEventRead ;
                break ;
                }
            
            default :
                {
                mapVar.Reset();
                IncorrectValueL( KFlagsKey.operator&() );  
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        
        if( val )
            {
            event->SetFlags( val ) ;
            }
        }
    
    if(evtmap->FindL( KSubjectKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KSubjectKey.operator&() );
        event->SetSubject( mapVar.AsDes() ) ;
        }
    
    if(evtmap->FindL( KPhoneNumberKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KPhoneNumberKey.operator&() );
        event->SetNumber( mapVar.AsDes() ) ;
        }
        
    if(evtmap->FindL( KEventDataKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC8, KEventDataKey.operator&() );
        event->SetDataL( mapVar.AsData() ) ;
        }
    
    if(evtmap->FindL( KLinkKey , mapVar ))
        {
        CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KLinkKey.operator&() );
        
        if( mapVar.AsTInt32()<0 )
          {
           mapVar.Reset();
           IncorrectValueL( KLinkKey.operator&() );
           User::Leave( SErrInvalidServiceArgument );
          }
         event->SetLink( mapVar.AsTInt32() ) ;
        }
    
    CleanupStack::Pop( &mapVar );
    
    mapVar.Reset();
        
    if( KLiwOptASyncronous & aCmdOptions )
        {
        if( aCallback!=NULL )
            {
            aTansId = MLiwNotifyCallback :: GetTransactionID() ;
            LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
            CleanupStack :: PushL( cb ) ;
            cb->SetRequestType( EAddEvent ) ;
            iLogService->AddEventL( aTansId, event, cb );
            CleanupStack::Pop( cb );
            CleanupStack::Pop( event );
            delete event ;
            return 0;
            }
        else
            {
            iErrorString = KErrMissingCallback.operator()().Alloc();
            User::Leave( SErrInvalidServiceArgument );
            }
        }
    else
        {
        TInt32 logid = iLogService->AddEventL(event) ;
        
        if(logid<0)
            {
            IncorrectValueL( KLogId.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
            
        CleanupStack::Pop(event);
        delete event ;
        return  logid ;
        }
    
    return 0;
    }

/**
 * Internal utility method, used to getlist from the core class
 *
 * @param aFilter, filter for getlist on core class
 * @param aTransid , value/result argument(TransactionId
 * @param aCallback, callback method for async events
 */
CLogIter*  CLoggingInterface :: GetListL(  const TLiwGenericParam  *aFilter,
                                           TUint& aTansId,
                                           TUint aCmdOptions,
                                           MLiwNotifyCallback  *aCallback )
    {
    if( aFilter && (aFilter->Value().TypeId() != LIW::EVariantTypeNull) )
        {
        CheckInputTypeL( &aFilter->Value(), LIW::EVariantTypeMap ,KFilter.operator&() );
        
        CLogsFilter *filter = CLogsFilter :: NewL() ;
        
        filter->SetRequestType( EReadEvents ) ;
        
        CleanupStack :: PushL( filter ) ;
        
        const CLiwMap *mapParam = (aFilter->Value()).AsMap() ;
        
        TLiwVariant var ;
        
        CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &var) );
        
        /**
        * Extract the contents of getlist filter
        * and issue request to the core class  accordingly
        */
        
        if( mapParam->FindL( KLogId ,var ) )
            {
            TInt32 logid;
            CheckInputTypeL( &var, LIW::EVariantTypeDesC, KLogId.operator&() );
            if( var.AsDes()!=KNullDesC16 )
                {
                if( var.AsDes().Length() < 256 )
                    {
                    TBuf<256> Val2 = var.AsDes();
                    TLex lex(Val2);
                    TInt32 error = lex.Val( logid );
                    if( error!=KErrNone )
                        {
                        var.Reset();
                        IncorrectValueL( KLogId.operator&() );
                        User::Leave( SErrInvalidServiceArgument );
                        }
                    }
                else
                    {
                    var.Reset();
                    IncorrectValueL( KLogId.operator&() );
                    User::Leave( SErrInvalidServiceArgument );
                    }
                    
                if( logid>-1 )
                    {
                    CleanupStack::Pop( &var );
                    var.Reset();
                    CLogsEvent *event =  CLogsEvent :: NewL();
                    CleanupStack :: PushL( event ) ;
                    event->SetId( logid );
                    filter->SetEventL( event ) ;
                    CleanupStack :: Pop( event ) ;
                    delete event ;
                    filter->SetRequestType( EGetEvent ) ;
        
                    if( KLiwOptASyncronous & aCmdOptions )
                        {
                        if( aCallback!=NULL )
                            {
                            aTansId = MLiwNotifyCallback :: GetTransactionID() ;
                            LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL(aCallback) ;
                            CleanupStack :: PushL( cb ) ;
                            cb->SetRequestType( EGetEvent ) ;
                            iLogService->GetListL( aTansId, filter, cb) ;
                            CleanupStack :: Pop( cb ) ;
                            CleanupStack :: Pop( filter ) ;
                            delete filter ;
                            return NULL;
                            }
                        else
                            {
                            iErrorString = KErrMissingCallback.operator()().Alloc();
                            User::Leave( SErrInvalidServiceArgument );
                            }
                        }
                     else
                        {
                        CLogIter *Iter = iLogService->GetListL( filter ) ;
                        CleanupStack :: Pop( filter ) ;
                        delete filter;
                        return Iter ;
                        }
                    }
                  else
                      {
                      var.Reset();
                      User::Leave( SErrInvalidServiceArgument );
                      }
                }
            }
                
        if( mapParam->FindL(KRecentListKey , var) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KRecentListKey.operator&() );
        
            TInt Val3 = var.AsTInt32();
        
            switch( Val3 )
                {
                case EKLogNullRecentList :
                    {
                    filter->SetRecentList( KLogNullRecentList ) ;
                    break;
                    }
        
                case EKLogRecentIncomingCalls :
                    {
                    filter->SetRecentList( KLogRecentIncomingCalls );
                    break;
                    }
    
                case EKLogRecentOutgoingCalls :
                    {
                    filter->SetRecentList( KLogRecentOutgoingCalls );
                    break;
                    }
    
                case EKLogRecentMissedCalls :
                    {
                    filter->SetRecentList( KLogRecentMissedCalls );
                    break;
                    }
                    
                default :
                    {
                    var.Reset();
                    IncorrectValueL( KRecentListKey.operator&() );  
                    User::Leave( SErrInvalidServiceArgument );
                    break ;
                    }
                }
                    
                
            CleanupStack::Pop( &var );
            var.Reset();    
            
            filter->SetRequestType(EGetRecent) ;
        
            if ( KLiwOptASyncronous & aCmdOptions )
                 {
                 if( aCallback!=NULL )
                     {
                     aTansId = MLiwNotifyCallback :: GetTransactionID() ;
                     LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
                     CleanupStack :: PushL( cb ) ;
                     cb->SetRequestType( EGetRecent ) ;
                     iLogService->GetListL( aTansId, filter, cb) ;
                     CleanupStack :: Pop( cb ) ;
                     CleanupStack :: Pop( filter ) ;
                     delete filter ;
                     return NULL;
                     }
                 else
                     {
                     iErrorString = KErrMissingCallback.operator()().Alloc();
                     User::Leave( SErrInvalidServiceArgument );
                     }
                 }
             else
                 {
                 CLogIter *Iter = iLogService->GetListL( filter ) ;
                 CleanupStack :: Pop( filter ) ;
                 delete filter;
                 return Iter;
                 }
                    
            }
        
        if( mapParam->FindL( KPhoneNumberKey ,var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeDesC, KPhoneNumberKey.operator&() );
            filter->SetNumber( var.AsDes() ) ;
            }
        
        if( mapParam->FindL( KDirectionKey ,var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KDirectionKey.operator&() );
            TInt val = 0 ;
        
            switch( var.AsTInt32() )
                {
                case EIncomingEvent:
                    {
                    val = R_LOG_DIR_IN ;
                    break ;
                    }
        
                case EOutgoingEvent :
                    {
                    val = R_LOG_DIR_OUT ;
                    break ;
                    }
        
                case EIncomingEventAlternateline :
                    {
                    val = R_LOG_DIR_IN_ALT ;
                    break ;
                    }
        
                case EOutgoingEventAlternateline :
                    {
                    val = R_LOG_DIR_OUT_ALT  ;
                    break ;
                    }
        
                case  EFetchedEvent :
                    {
                    val = R_LOG_DIR_FETCHED ;
                    break ;
                    }
        
                case EMissedEvent :
                    {
                    val = R_LOG_DIR_MISSED ;
                    break ;
                    }
        
                case EMissedEventAlternateline :
                    {
                    val = R_LOG_DIR_MISSED_ALT ;
                    break ;
                    }
        
                default :
                    {
                    var.Reset();
                    IncorrectValueL( KDirectionKey.operator&() );  
                    User::Leave( SErrInvalidServiceArgument );
                    }
                }
        
            if( val )
                {
                filter->SetDirection( val ) ;
                }
            }
        
        if( mapParam->FindL(KDeliveryStatusKey ,var) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KDeliveryStatusKey.operator&() );
            TInt val = 0 ;
        
            switch( var.AsTInt32() )
                {
                case EStatusPending :
                    {
                    val =  R_LOG_DEL_PENDING ;
                    break ;
                    }
        
                case EStatusSent :
                    {
                    val = R_LOG_DEL_SENT ;
                    break ;
                    }
        
                case EStatusFalied :
                    {
                    val = R_LOG_DEL_FAILED ;
                    break ;
                    }
        
                case EStatusNone :
                    {
                    val = R_LOG_DEL_NONE  ;
                    break ;
                    }
        
                case  EStatusDone :
                    {
                    val = R_LOG_DEL_DONE ;
                    break ;
                    }
        
                case EStatusNotSent :
                    {
                    val = R_LOG_DEL_NOT_SENT ;
                    break ;
                    }
        
                case EStatusScheduled :
                    {
                    val = R_LOG_DEL_SCHEDULED ;
                    break ;
                    }
        
                default :
                    {
                    var.Reset();
                    IncorrectValueL( KDeliveryStatusKey.operator&() ); 
                    User::Leave( SErrInvalidServiceArgument ); 
                    }
                }
        
            if( val )
                {
                filter->SetStatus(val) ;
                }
            }
        
        if( mapParam->FindL( KFlagsKey , var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KFlagsKey.operator&() );
            TUint8 val = 0 ;
            
            switch( var.AsTInt32() )
                {
                case EKLogEventContactSearched :
                    {
                    val = KLogEventContactSearched ;
                    break ;
                    }
            
                case EKLogEventRead :
                    {
                    val = KLogEventRead ;
                    break ;
                    }
            
                default :
                    {
                    var.Reset();
                    IncorrectValueL( KFlagsKey.operator&() );  
                    User::Leave( SErrInvalidServiceArgument );
                    }
                }
            
            if( val )
                {
                filter->SetFlags( val ) ;
                }
            }
                
        if( mapParam->FindL( KEndTimeKey , var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTTime, KEndTimeKey.operator&() );
            filter->SetEndTime( var.AsTTime() ) ;
            }
               
        if( mapParam->FindL( KRemotePartyKey , var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeDesC, KRemotePartyKey.operator&() );
            filter->SetRemoteParty( var.AsDes() ) ;
            }
                
        if( mapParam->FindL( KEventTypeKey , var ) )
            {
            CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KEventTypeKey.operator&() );
            TUid val = TUid::Null() ;
            
            switch( var.AsTInt32() )
                {
                case EKLogCallEventType :
                    {
                    val =  TUid :: Uid(KLogCallEventType);
                    break ;
                    }
        
                case EKLogDataEventType :
                    {
                    val = TUid :: Uid (KLogDataEventType);
                    break ;
                    }
        
                case EKLogFaxEventType :
                    {
                    val = TUid :: Uid (KLogFaxEventType);
                    break ;
                    }
        
                case EKLogShortMessageEventType :
                    {
                    val = TUid :: Uid (KLogShortMessageEventType);
                    break ;
                    }
                    
               case EKLogPacketDataEventType :
                    {
                    val = TUid :: Uid (KLogPacketDataEventType) ;
                    break ;
                    }          
        
               default :
                    {
                    var.Reset();
                    IncorrectValueL( KFlagsKey.operator&() );  
                    User::Leave( SErrInvalidServiceArgument );
                    }
                }
                
            if( val!=TUid::Null() )
                {
                filter->SetEventType( val ) ;
                }
            }
        
        CleanupStack::Pop( &var );
        
        var.Reset();
        
        if ( KLiwOptASyncronous & aCmdOptions )
            {
            if( aCallback!=NULL )
                {
                aTansId = MLiwNotifyCallback :: GetTransactionID() ;
                LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
                CleanupStack :: PushL( cb ) ;
                cb->SetRequestType( EReadEvents ) ;
                iLogService->GetListL( aTansId, filter, cb ) ;
                CleanupStack :: Pop( cb ) ;
                CleanupStack :: Pop( filter ) ;
                delete filter ;
                return NULL;
                }
            else
                {
                iErrorString = KErrMissingCallback.operator()().Alloc();
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        else
            {
            CLogIter *Iter = iLogService->GetListL(filter) ;
            CleanupStack :: Pop(filter) ;
            delete filter;
            return Iter;
            }
        }
    else
        {
        CLogsFilter *filter = CLogsFilter :: NewL() ;
        
        filter->SetRequestType( EReadEvents ) ;
        
        CleanupStack :: PushL( filter ) ;
        
        if ( KLiwOptASyncronous & aCmdOptions )
            {
            if( aCallback!=NULL )
                {
                aTansId = MLiwNotifyCallback :: GetTransactionID() ;
                LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
                CleanupStack :: PushL( cb ) ;
                cb->SetRequestType( EReadEvents ) ;
                iLogService->GetListL( aTansId , filter , cb ) ;
                CleanupStack :: Pop( cb ) ;
                CleanupStack :: Pop( filter ) ;
                delete filter ;
                return NULL;
                }
            else
                {
                iErrorString = KErrMissingCallback.operator()().Alloc();
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        else
            {
            CLogIter *Iter = iLogService->GetListL(filter) ;
            CleanupStack :: Pop(filter) ;
            delete filter;
            return Iter;
            }
        }
    
    return 0;
    }

/**
 * Internal utility method, used for notification registration
 *
 * @param aCallback, callback address for notification requests.
 */

TInt CLoggingInterface :: RequestNotificationsL( const TLiwGenericParam *aParam ,
                                                 MLiwNotifyCallback *aCallback ,
                                                 TUint& aTransId,
                                                 TUint aCmdOptions )
    {
    TInt32 timeDelay = 0;
    
    CheckInputTypeL( &aParam->Value(), LIW::EVariantTypeMap ,KFilter.operator&() );
    
    const CLiwMap *notifymap = (aParam->Value()).AsMap() ;
    
     if( !notifymap )
        {
        MissingValueL( KFilter.operator&() );
        }
        
    TLiwVariant variant ;  
    
    if( notifymap->FindL( KDelayTime , variant ) ) 
        {
        CheckInputTypeL( &variant, LIW::EVariantTypeTInt32, KDelayTime.operator&() );
        timeDelay = variant.AsTInt32() ; 
        }
    else
        {
        MissingValueL( KDelayTime.operator&() );
        }   
        
    if( timeDelay < 0 )
        {
        variant.Reset();
        IncorrectValueL( KDelayTime.operator&() );
        User::Leave( SErrInvalidServiceArgument );
        }
        
    variant.Reset();
    
    TTimeIntervalMicroSeconds32 DelayInterval = timeDelay ;
    
    if( aCallback && ( KLiwOptASyncronous & aCmdOptions ) )
        {
        aTransId = MLiwNotifyCallback :: GetTransactionID() ;
        LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
        CleanupStack :: PushL( cb ) ;
        cb->SetRequestType( ENotification ) ;
        iLogService->NotifyUpdatesL( aTransId, DelayInterval, cb) ;
        CleanupStack :: Pop( cb ) ;
        return 0 ;
        }
    else
        {
        iErrorString = KErrMissingCallback.operator()().Alloc();
        User::Leave( SErrInvalidServiceArgument );
        }
    
    return 0;    
    }

 /**
  * Internal utility method, used for Delete from the core class
  *
  * @param aParam, input paramater containg the logid
  * @param aCallback, callback address for notification requests.
  * @param aTransId, transaction id.
  */
TInt CLoggingInterface::DeleteEventL( const TLiwGenericParam *aParam ,
                                      TUint& aTansId ,
                                      TUint aCmdOptions,
                                      MLiwNotifyCallback* aCallback )
    {
    TInt32 logid;
    
    CheckInputTypeL( &aParam->Value(), LIW::EVariantTypeMap ,KData.operator&() );
    
    const CLiwMap *delmap = (aParam->Value()).AsMap() ;
    
    if( !delmap )
        {
        MissingValueL( KData.operator&() );
        }
    
    TLiwVariant variant ;
    
    if( delmap->FindL( KLogId , variant ) )
        {
        CheckInputTypeL( &variant, LIW::EVariantTypeDesC, KLogId.operator&() );
        
        if( variant.AsDes().Length() < 256 )
            {
            TBuf<256> itemid = variant.AsDes();
            TLex lex(itemid);
            TInt32 error = lex.Val(logid);
        
            if( error!=KErrNone )
                {
                variant.Reset();
                IncorrectValueL( KLogId.operator&() );
                User::Leave( SErrInvalidServiceArgument );
                }
            }
        else
            {
            variant.Reset();
            IncorrectValueL( KLogId.operator&() );
            User::Leave( SErrInvalidServiceArgument );
            }
        }
    else
        {
        MissingValueL( KLogId.operator&() );
        }
    
    variant.Reset();
        
    if( KLiwOptASyncronous & aCmdOptions )
        {
        if( aCallback!=NULL )
            {
            aTansId = MLiwNotifyCallback :: GetTransactionID() ;
            LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;
            CleanupStack :: PushL( cb ) ;
            cb->SetRequestType( EDeleteEvent ) ;
            iLogService->DeleteEventL( aTansId, logid, cb );
            CleanupStack :: Pop( cb ) ;
            return 0;
            }
        else
            {
            iErrorString = KErrMissingCallback.operator()().Alloc();
            User::Leave( SErrInvalidServiceArgument );
            }
        }
    else
        {
        return iLogService->DeleteEventL(logid );
        }
    
    return 0;
    }





