--- /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;
+ }
+
+
+
+
+