diff -r a36b1e19a461 -r 989d2f495d90 serviceproviders/sapi_logging/src/logginginterface.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_logging/src/logginginterface.cpp	Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,1558 @@
+/*
+* 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;
+    }
+
+
+
+
+